static void
update_capabilities (NMSupplicantManager *self)
{
NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self);
NMSupplicantInterface *iface;
GHashTableIter hash_iter;
const char **array;
GVariant *value;
/* The supplicant only advertises global capabilities if the following
* commit has been applied:
*
* commit 1634ac0654eba8d458640a115efc0a6cde3bac4d
* Author: Dan Williams <*****@*****.**>
* Date: Sat Sep 29 19:06:30 2012 +0300
*
* dbus: Add global capabilities property
*/
priv->ap_support = AP_SUPPORT_UNKNOWN;
value = g_dbus_proxy_get_cached_property (priv->proxy, "Capabilities");
if (value) {
if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING_ARRAY)) {
array = g_variant_get_strv (value, NULL);
priv->ap_support = AP_SUPPORT_NO;
if (_nm_utils_string_in_list ("ap", array))
priv->ap_support = AP_SUPPORT_YES;
g_free (array);
}
g_variant_unref (value);
}
/* Tell all interfaces about results of the AP check */
g_hash_table_iter_init (&hash_iter, priv->ifaces);
while (g_hash_table_iter_next (&hash_iter, NULL, (gpointer) &iface))
nm_supplicant_interface_set_ap_support (iface, priv->ap_support);
nm_log_dbg (LOGD_SUPPLICANT, "AP mode is %ssupported",
(priv->ap_support == AP_SUPPORT_YES) ? "" :
(priv->ap_support == AP_SUPPORT_NO) ? "not " : "possibly ");
/* EAP-FAST */
priv->fast_supported = FALSE;
value = g_dbus_proxy_get_cached_property (priv->proxy, "EapMethods");
if (value) {
if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING_ARRAY)) {
array = g_variant_get_strv (value, NULL);
if (_nm_utils_string_in_list ("fast", array))
priv->fast_supported = TRUE;
g_free (array);
}
g_variant_unref (value);
}
nm_log_dbg (LOGD_SUPPLICANT, "EAP-FAST is %ssupported", priv->fast_supported ? "" : "not ");
}
static void
ide_editor_frame_actions_replace_confirm (GSimpleAction *action,
GVariant *state,
gpointer user_data)
{
IdeEditorFrame *self = user_data;
g_autofree const gchar **strv = NULL;
gsize array_length;
g_assert (IDE_IS_EDITOR_FRAME (self));
g_assert (state != NULL);
g_assert (g_variant_is_of_type (state, G_VARIANT_TYPE_STRING_ARRAY));
strv = g_variant_get_strv (state, &array_length);
g_assert (array_length >= 2);
gtk_entry_set_text (GTK_ENTRY (self->search_entry), strv[0]);
gtk_entry_set_text (GTK_ENTRY (self->replace_entry), strv[1]);
gtk_widget_show (GTK_WIDGET (self->replace_entry));
gtk_widget_show (GTK_WIDGET (self->replace_button));
gtk_widget_show (GTK_WIDGET (self->replace_all_button));
/* increment pending_replace_confirm so that search_revealer_on_child_revealed_changed
* will know to go to the next search result (the occurrence only stays selected after
* search_entry has been mapped).
*/
self->pending_replace_confirm++;
gtk_revealer_set_reveal_child (self->search_revealer, TRUE);
gtk_widget_grab_focus (GTK_WIDGET (self->search_entry));
}
static void
shell_action_handle_uris_cb (GSimpleAction *action,
GVariant *parameter,
EShell *shell)
{
const gchar **uris;
gchar *change_dir = NULL;
gint ii;
/* Do not use g_strfreev() here. */
uris = g_variant_get_strv (parameter, NULL);
if (uris && g_strcmp0 (uris[0], "--use-cwd") == 0 && uris[1] && *uris[1]) {
change_dir = g_get_current_dir ();
if (g_chdir (uris[1]) != 0)
g_warning ("%s: Failed to change directory to '%s': %s", G_STRFUNC, uris[1], g_strerror (errno));
for (ii = 0; uris[ii + 2]; ii++) {
uris[ii] = uris[ii + 2];
}
uris[ii] = NULL;
}
e_shell_handle_uris (shell, uris, FALSE);
g_free (uris);
if (change_dir) {
if (g_chdir (change_dir) != 0)
g_warning ("%s: Failed to return back to '%s': %s", G_STRFUNC, change_dir, g_strerror (errno));
g_free (change_dir);
}
}
static gboolean
switch_settings_mapping_get_generic (GValue *value,
GVariant *variant,
GtkWidget *row,
gboolean default_enabled)
{
GAppInfo *app_info = g_object_get_data (G_OBJECT (row), "app-info");
const gchar **apps;
gint idx;
gboolean found;
found = FALSE;
apps = g_variant_get_strv (variant, NULL);
for (idx = 0; apps[idx] != NULL; idx++)
{
if (g_strcmp0 (apps[idx], g_app_info_get_id (app_info)) == 0)
{
found = TRUE;
break;
}
}
g_value_set_boolean (value, !!default_enabled != !!found);
return TRUE;
}
static void PutEntry(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)
{
gsize len = 0;
GVariant *array = g_variant_get_child_value(Parameters, 0);
const gchar **line = g_variant_get_strv(array, &len);
if (len < 1) {
g_free(line);
cDBusHelper::SendReply(Invocation, 501, "at least one element must be given");
return;
}
cPUTEhandler *handler = new cPUTEhandler();
if (handler->Status() == 354) {
for (gsize i = 0; i < len; i++) {
d4syslog("dbus2vdr: %s.PutEntry: item = %s", DBUS_VDR_EPG_INTERFACE, line[i]);
d4syslog("dbus2vdr: %s.PutEntry: status = %d, message = %s", DBUS_VDR_EPG_INTERFACE, handler->Status(), handler->Message());
if (!handler->Process(line[i]))
break;
}
d4syslog("dbus2vdr: %s.PutEntry: status = %d, message = %s", DBUS_VDR_EPG_INTERFACE, handler->Status(), handler->Message());
if (handler->Status() == 354)
handler->Process(".");
}
cDBusHelper::SendReply(Invocation, handler->Status(), handler->Message());
delete handler;
g_free(line);
};
static void
carrick_connman_manager_handle_property (CarrickConnmanManager *self,
const char *key,
GVariant *value)
{
gboolean offline_mode;
const char **techs;
if (g_strcmp0 (key, "AvailableTechnologies") == 0) {
techs = g_variant_get_strv (value, NULL);
carrick_connman_manager_set_available_techs (self, techs);
} else if (g_strcmp0 (key, "EnabledTechnologies") == 0) {
techs = g_variant_get_strv (value, NULL);
carrick_connman_manager_set_enabled_techs (self, techs);
} else if (g_strcmp0 (key, "OfflineMode") == 0) {
offline_mode = g_variant_get_boolean (value);
carrick_connman_manager_update_offline_mode (self, offline_mode);
}
}
static void
_take_variant_property_uuids (NMBluezDevice *self, GVariant *v)
{
if (VARIANT_IS_OF_TYPE_STRING_ARRAY (v)) {
const char **uuids = g_variant_get_strv (v, NULL);
_set_property_capabilities (self, uuids);
g_free (uuids);
}
if (v)
g_variant_unref (v);
}
static gchar *list_player_names(GError **err)
{
GString *names_str = g_string_new("");
GError *tmp_error = NULL;
GDBusProxy *proxy = g_dbus_proxy_new_for_bus_sync(
G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
NULL,
&tmp_error);
if (tmp_error != NULL) {
g_propagate_error(err, tmp_error);
return NULL;
}
GVariant *reply = g_dbus_proxy_call_sync(proxy,
"ListNames",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&tmp_error);
if (tmp_error != NULL) {
g_propagate_error(err, tmp_error);
g_object_unref(proxy);
return NULL;
}
GVariant *reply_child = g_variant_get_child_value(reply, 0);
gsize reply_count;
const gchar** names = g_variant_get_strv(reply_child, &reply_count);
for (int i = 0; i < reply_count; i += 1) {
if (g_str_has_prefix(names[i], "org.mpris.MediaPlayer2")) {
gchar **bus_name_split = g_strsplit(names[i], ".", 4);
g_string_append_printf(names_str, "%s\n", bus_name_split[3]);
g_strfreev(bus_name_split);
}
}
g_object_unref(proxy);
g_variant_unref(reply);
g_variant_unref(reply_child);
g_free(names);
return g_string_free(names_str, FALSE);
}
/**
* playerctl_player_print_metadata_prop:
* @self: a #PlayerctlPlayer
* @property: (allow-none): the property from the metadata to print
* @err: (allow-none): the location of a GError or NULL
*
* Gets the artist from the metadata of the current track, or empty string if
* no track is playing.
*
* Returns: (transfer full): The artist from the metadata of the current track
*/
gchar *playerctl_player_print_metadata_prop(PlayerctlPlayer *self, gchar *property, GError **err)
{
GVariant *prop_variant;
const gchar **prop_strv;
GString *prop;
GVariant *metadata;
GError *tmp_error = NULL;
g_return_val_if_fail(err == NULL || *err == NULL, NULL);
if (self->priv->init_error != NULL) {
g_propagate_error(err, g_error_copy(self->priv->init_error));
return NULL;
}
metadata = org_mpris_media_player2_player_get_metadata(self->priv->proxy);
if (!metadata)
return g_strdup("");
if (!property)
return g_variant_print(metadata, FALSE);
prop_variant = g_variant_lookup_value(metadata, property, NULL);
if (!prop_variant)
return g_strdup("");
prop = g_string_new("");
if (g_variant_is_of_type(prop_variant, G_VARIANT_TYPE_STRING_ARRAY)) {
gsize prop_count;
prop_strv = g_variant_get_strv(prop_variant, &prop_count);
for (int i = 0; i < prop_count; i += 1) {
g_string_append(prop, prop_strv[i]);
if (i != prop_count - 1) {
g_string_append(prop, ", ");
}
}
g_free(prop_strv);
} else if (g_variant_is_of_type(prop_variant, G_VARIANT_TYPE_STRING)) {
g_string_append(prop, g_variant_get_string(prop_variant, NULL));
} else {
prop = g_variant_print_string(prop_variant, prop, FALSE);
}
return g_string_free(prop, FALSE);
}
static bool CALEDeviceFilter(GDBusProxy * device)
{
bool accepted = false;
/*
Filter out any devices that don't support the OIC Transport
Profile service.
*/
GVariant * const prop =
g_dbus_proxy_get_cached_property(device, "UUIDs");
if (prop == NULL)
{
// No remote services available on the device.
return accepted;
}
gsize length = 0;
char const ** const UUIDs = g_variant_get_strv(prop, &length);
/*
It would have been nice to use g_strv_contains() here, but we
would need to run it twice: once for the uppercase form of the
UUID and once for for the lowercase form. Just run the loop
manually, and use strcasecmp() instead.
*/
char const * const * const end = UUIDs + length;
for (char const * const * u = UUIDs; u != end; ++u)
{
if (strcasecmp(*u, CA_GATT_SERVICE_UUID) == 0)
{
accepted = true;
break;
}
}
g_free(UUIDs);
g_variant_unref(prop);
return accepted;
}
static gboolean
switch_tracker_get_mapping (GValue *value,
GVariant *variant,
gpointer user_data)
{
Place *place = user_data;
const gchar **locations;
GFile *location;
gint idx;
gboolean found;
found = FALSE;
locations = g_variant_get_strv (variant, NULL);
for (idx = 0; locations[idx] != NULL; idx++)
{
location = g_file_new_for_path (path_from_tracker_dir(locations[idx]));
if ((found = g_file_equal (location, place->location)))
break;
}
g_value_set_boolean (value, found);
return TRUE;
}
static void
setup_commit_passwd1 (GVariant *parameters,
GDBusMethodInvocation *invocation)
{
const gchar *mechanism;
GVariant *transferred = NULL;
const gchar **lines;
GHashTable *users = NULL;
GHashTable *groups = NULL;
GString *chpasswd = NULL;
GString *newusers = NULL;
CommitAdmin1 *context;
CockpitPipe *pipe;
gsize length, i, j;
gchar **parts;
GBytes *bytes;
GVariant *pwdata = NULL;
GVariant *grdata = NULL;
GHashTable *usermod;
gchar **memlist;
GString *string;
gboolean user_exists;
/* We are getting crypted passwords so we need to use
* --crypt-method=NONE with newusers and chpasswd so that the string
* is installed unchanged. Unfortunately, newusers might or might
* not support the --crypt-method option, depending on whether it
* was compiled with or without PAM. When the option is missing, we
* fix up the password afterwards via chpasswd.
*
* However, newusers needs some valid password to create new users.
* Thus, we need a good random string that passes all password
* quality criteria, and we just use the crpyted password for that.
*/
const gchar *argv[] = { cockpit_bridge_path_newusers, "--crypt-method=NONE", NULL };
if (!cockpit_bridge_have_newusers_crypt_method)
argv[1] = NULL;
g_variant_get (parameters, "(&sv)", &mechanism, &transferred);
if (!g_str_equal (mechanism, "passwd1"))
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED,
"Unsupported setup mechanism: %s", mechanism);
goto out;
}
if (!g_variant_is_of_type (transferred, G_VARIANT_TYPE ("(asas)")))
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
"Bad data passed for passwd1 mechanism");
goto out;
}
users = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
groups = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
if (!fgetpwent_callback (add_name_to_hashtable, users) ||
!fgetgrent_callback (add_group_to_hashtable, groups))
{
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_FAILED,
_("Couldn't list local users"));
goto out;
}
g_debug ("starting setup synchronization");
g_variant_get (transferred, "(@as@as)", &pwdata, &grdata);
chpasswd = g_string_new ("");
newusers = g_string_new ("");
usermod = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, string_free);
lines = g_variant_get_strv (pwdata, &length);
for (i = 0; i < length; i++)
{
parts = g_strsplit(lines[i], ":", 3);
user_exists = (g_hash_table_lookup (users, parts[0]) != NULL);
if (!user_exists)
{
g_string_append (newusers, lines[i]);
g_string_append_c (newusers, '\n');
}
if (user_exists || !cockpit_bridge_have_newusers_crypt_method)
{
g_string_append_printf (chpasswd, "%s:%s\n", parts[0], parts[1]);
}
g_strfreev (parts);
}
g_free (lines);
lines = g_variant_get_strv (grdata, &length);
for (i = 0; i < length; i++)
{
parts = g_strsplit(lines[i], ":", 4);
if (g_hash_table_lookup (groups, parts[0]))
{
memlist = g_strsplit (parts[3], ",", -1);
for (j = 0; memlist[j] != NULL; j++)
{
string = g_hash_table_lookup (usermod, memlist[j]);
if (!string)
{
string = g_string_new ("");
g_hash_table_insert (usermod, g_strdup (memlist[j]), string);
}
if (string->len > 0)
g_string_append_c (string, ',');
g_string_append (string, parts[0]);
}
g_strfreev (memlist);
}
g_strfreev (parts);
}
g_free (lines);
context = g_new0 (CommitAdmin1, 1);
context->invocation = g_object_ref (invocation);
context->chpasswd = g_string_free_to_bytes (chpasswd);
context->usermod = usermod;
g_debug ("batch creating new users");
bytes = g_string_free_to_bytes (newusers);
pipe = cockpit_pipe_spawn (argv, NULL, NULL, COCKPIT_PIPE_FLAGS_NONE);
g_signal_connect (pipe, "close", G_CALLBACK (on_newusers_close), context);
cockpit_pipe_write (pipe, bytes);
cockpit_pipe_close (pipe, NULL);
g_bytes_unref (bytes);
out:
if (users)
g_hash_table_unref (users);
if (groups)
g_hash_table_unref (groups);
if (pwdata)
g_variant_unref (pwdata);
if (grdata)
g_variant_unref (grdata);
g_variant_unref (transferred);
}
static gchar *playerctl_player_get_bus_name(PlayerctlPlayer *self, GError **err)
{
gchar *bus_name = NULL;
GError *tmp_error = NULL;
g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
if (self->priv->bus_name != NULL) {
return self->priv->bus_name;
}
if (self->priv->player_name != NULL) {
bus_name = g_strjoin(".", "org.mpris.MediaPlayer2", self->priv->player_name, NULL);
} else {
GDBusProxy *proxy = g_dbus_proxy_new_for_bus_sync(
G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
NULL,
&tmp_error);
if (tmp_error != NULL) {
g_propagate_error(err, tmp_error);
return NULL;
}
GVariant *reply = g_dbus_proxy_call_sync(proxy,
"ListNames",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&tmp_error);
if (tmp_error != NULL) {
g_propagate_error(err, tmp_error);
g_object_unref(proxy);
return NULL;
}
GVariant *reply_child = g_variant_get_child_value(reply, 0);
gsize reply_count;
const gchar** names = g_variant_get_strv(reply_child, &reply_count);
for (int i = 0; i < reply_count; i += 1) {
if (g_str_has_prefix(names[i], "org.mpris.MediaPlayer2")) {
bus_name = g_strdup(names[i]);
break;
}
}
g_object_unref(proxy);
g_variant_unref(reply);
g_variant_unref(reply_child);
g_free(names);
}
if (bus_name == NULL) {
tmp_error = g_error_new(playerctl_player_error_quark(), 1, "No players found");
g_propagate_error(err, tmp_error);
return NULL;
}
return bus_name;
}
static gboolean
handle_set (GVfsMetadata *object,
GDBusMethodInvocation *invocation,
const gchar *arg_treefile,
const gchar *arg_path,
GVariant *arg_data,
GVfsMetadata *daemon)
{
TreeInfo *info;
const gchar *str;
const gchar **strv;
const gchar *key;
GError *error;
GVariantIter iter;
GVariant *value;
info = tree_info_lookup (arg_treefile);
if (info == NULL)
{
g_dbus_method_invocation_return_error (invocation,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
_("Can't find metadata file %s"),
arg_treefile);
return TRUE;
}
error = NULL;
g_variant_iter_init (&iter, arg_data);
while (g_variant_iter_next (&iter, "{&sv}", &key, &value))
{
if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING_ARRAY))
{
/* stringv */
strv = g_variant_get_strv (value, NULL);
if (!meta_tree_set_stringv (info->tree, arg_path, key, (gchar **) strv))
{
g_set_error_literal (&error, G_IO_ERROR,
G_IO_ERROR_FAILED,
_("Unable to set metadata key"));
}
g_free (strv);
}
else if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
{
/* string */
str = g_variant_get_string (value, NULL);
if (!meta_tree_set_string (info->tree, arg_path, key, str))
{
g_set_error_literal (&error, G_IO_ERROR,
G_IO_ERROR_FAILED,
_("Unable to set metadata key"));
}
}
else if (g_variant_is_of_type (value, G_VARIANT_TYPE_BYTE))
{
/* Unset */
if (!meta_tree_unset (info->tree, arg_path, key))
{
g_set_error_literal (&error, G_IO_ERROR,
G_IO_ERROR_FAILED,
_("Unable to unset metadata key"));
}
}
g_variant_unref (value);
}
tree_info_schedule_writeout (info);
if (error)
{
g_dbus_method_invocation_return_gerror (invocation, error);
g_error_free (error);
}
else
{
gvfs_metadata_complete_set (object, invocation);
}
return TRUE;
}
void show_dev_detail(void)
{
struct sr_dev_inst *sdi;
const struct sr_config_info *srci;
struct sr_channel *ch;
struct sr_channel_group *channel_group, *cg;
GSList *devices, *cgl, *chl;
GVariant *gvar_opts, *gvar_dict, *gvar_list, *gvar;
gsize num_opts, num_elements;
double dlow, dhigh, dcur_low, dcur_high;
const uint64_t *uint64, p, q, low, high;
uint64_t cur_low, cur_high;
const int32_t *int32, *opts;
unsigned int num_devices, o, i;
char *tmp_str;
char *s, c;
const char **stropts;
if (!(devices = device_scan())) {
g_critical("No devices found.");
return;
}
num_devices = g_slist_length(devices);
if (num_devices > 1) {
g_critical("%d devices found. Use --scan to show them, "
"and select one to show.", num_devices);
return;
}
sdi = devices->data;
print_dev_line(sdi);
if (sr_dev_open(sdi) != SR_OK) {
g_critical("Failed to open device.");
return;
}
if ((sr_config_list(sdi->driver, NULL, NULL, SR_CONF_SCAN_OPTIONS,
&gvar_opts) == SR_OK)) {
opts = g_variant_get_fixed_array(gvar_opts, &num_elements,
sizeof(int32_t));
printf("Supported driver options:\n");
for (i = 0; i < num_elements; i++) {
if (!(srci = sr_config_info_get(opts[i])))
continue;
printf(" %s\n", srci->id);
}
g_variant_unref(gvar_opts);
}
/* Selected channels and channel group may affect which options are
* returned, or which values for them. */
select_channels(sdi);
channel_group = select_channel_group(sdi);
if ((sr_config_list(sdi->driver, sdi, channel_group, SR_CONF_DEVICE_OPTIONS,
&gvar_opts)) != SR_OK)
/* Driver supports no device instance options. */
return;
if (sdi->channel_groups) {
printf("Channel groups:\n");
for (cgl = sdi->channel_groups; cgl; cgl = cgl->next) {
cg = cgl->data;
printf(" %s: channel%s", cg->name,
g_slist_length(cg->channels) > 1 ? "s" : "");
for (chl = cg->channels; chl; chl = chl->next) {
ch = chl->data;
printf(" %s", ch->name);
}
printf("\n");
}
}
printf("Supported configuration options");
if (sdi->channel_groups) {
if (!channel_group)
printf(" across all channel groups");
else
printf(" on channel group %s", channel_group->name);
}
printf(":\n");
opts = g_variant_get_fixed_array(gvar_opts, &num_opts, sizeof(int32_t));
for (o = 0; o < num_opts; o++) {
if (!(srci = sr_config_info_get(opts[o])))
continue;
if (srci->key == SR_CONF_TRIGGER_MATCH) {
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar_list) != SR_OK) {
printf("\n");
continue;
}
int32 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(int32_t));
printf(" Supported triggers: ");
for (i = 0; i < num_elements; i++) {
switch(int32[i]) {
case SR_TRIGGER_ZERO:
c = '0';
break;
case SR_TRIGGER_ONE:
c = '1';
break;
case SR_TRIGGER_RISING:
c = 'r';
break;
case SR_TRIGGER_FALLING:
c = 'f';
break;
case SR_TRIGGER_EDGE:
c = 'e';
break;
case SR_TRIGGER_OVER:
c = 'o';
break;
case SR_TRIGGER_UNDER:
c = 'u';
break;
default:
c = 0;
break;
}
if (c)
printf("%c ", c);
}
printf("\n");
g_variant_unref(gvar_list);
} else if (srci->key == SR_CONF_LIMIT_SAMPLES) {
/* If implemented in config_list(), this denotes the
* maximum number of samples a device can send. This
* really applies only to logic analyzers, and then
* only to those that don't support compression, or
* have it turned off by default. The values returned
* are the low/high limits. */
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar) != SR_OK) {
continue;
}
g_variant_get(gvar, "(tt)", &low, &high);
g_variant_unref(gvar);
printf(" Maximum number of samples: %"PRIu64"\n", high);
} else if (srci->key == SR_CONF_SAMPLERATE) {
/* Supported samplerates */
printf(" %s", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group, SR_CONF_SAMPLERATE,
&gvar_dict) != SR_OK) {
printf("\n");
continue;
}
if ((gvar_list = g_variant_lookup_value(gvar_dict,
"samplerates", G_VARIANT_TYPE("at")))) {
uint64 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(uint64_t));
printf(" - supported samplerates:\n");
for (i = 0; i < num_elements; i++) {
if (!(s = sr_samplerate_string(uint64[i])))
continue;
printf(" %s\n", s);
g_free(s);
}
g_variant_unref(gvar_list);
} else if ((gvar_list = g_variant_lookup_value(gvar_dict,
"samplerate-steps", G_VARIANT_TYPE("at")))) {
uint64 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(uint64_t));
/* low */
if (!(s = sr_samplerate_string(uint64[0])))
continue;
printf(" (%s", s);
g_free(s);
/* high */
if (!(s = sr_samplerate_string(uint64[1])))
continue;
printf(" - %s", s);
g_free(s);
/* step */
if (!(s = sr_samplerate_string(uint64[2])))
continue;
printf(" in steps of %s)\n", s);
g_free(s);
g_variant_unref(gvar_list);
}
g_variant_unref(gvar_dict);
} else if (srci->key == SR_CONF_BUFFERSIZE) {
/* Supported buffer sizes */
printf(" %s", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group,
SR_CONF_BUFFERSIZE, &gvar_list) != SR_OK) {
printf("\n");
continue;
}
uint64 = g_variant_get_fixed_array(gvar_list,
&num_elements, sizeof(uint64_t));
printf(" - supported buffer sizes:\n");
for (i = 0; i < num_elements; i++)
printf(" %"PRIu64"\n", uint64[i]);
g_variant_unref(gvar_list);
} else if (srci->key == SR_CONF_TIMEBASE) {
/* Supported time bases */
printf(" %s", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group,
SR_CONF_TIMEBASE, &gvar_list) != SR_OK) {
printf("\n");
continue;
}
printf(" - supported time bases:\n");
num_elements = g_variant_n_children(gvar_list);
for (i = 0; i < num_elements; i++) {
gvar = g_variant_get_child_value(gvar_list, i);
g_variant_get(gvar, "(tt)", &p, &q);
s = sr_period_string(p * q);
printf(" %s\n", s);
g_free(s);
}
g_variant_unref(gvar_list);
} else if (srci->key == SR_CONF_VDIV) {
/* Supported volts/div values */
printf(" %s", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group,
SR_CONF_VDIV, &gvar_list) != SR_OK) {
printf("\n");
continue;
}
printf(" - supported volts/div:\n");
num_elements = g_variant_n_children(gvar_list);
for (i = 0; i < num_elements; i++) {
gvar = g_variant_get_child_value(gvar_list, i);
g_variant_get(gvar, "(tt)", &p, &q);
s = sr_voltage_string(p, q);
printf(" %s\n", s);
g_free(s);
}
g_variant_unref(gvar_list);
} else if (srci->datatype == SR_T_STRING) {
printf(" %s: ", srci->id);
if (sr_config_get(sdi->driver, sdi, channel_group, srci->key,
&gvar) == SR_OK) {
tmp_str = g_strdup(g_variant_get_string(gvar, NULL));
g_variant_unref(gvar);
} else
tmp_str = NULL;
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar) != SR_OK) {
printf("\n");
continue;
}
stropts = g_variant_get_strv(gvar, &num_elements);
for (i = 0; i < num_elements; i++) {
if (i)
printf(", ");
printf("%s", stropts[i]);
if (tmp_str && !strcmp(tmp_str, stropts[i]))
printf(" (current)");
}
printf("\n");
g_free(stropts);
g_free(tmp_str);
g_variant_unref(gvar);
} else if (srci->datatype == SR_T_UINT64_RANGE) {
printf(" %s: ", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar_list) != SR_OK) {
printf("\n");
continue;
}
if (sr_config_get(sdi->driver, sdi, NULL, srci->key, &gvar) == SR_OK) {
g_variant_get(gvar, "(tt)", &cur_low, &cur_high);
g_variant_unref(gvar);
} else {
cur_low = 0;
cur_high = 0;
}
num_elements = g_variant_n_children(gvar_list);
for (i = 0; i < num_elements; i++) {
gvar = g_variant_get_child_value(gvar_list, i);
g_variant_get(gvar, "(tt)", &low, &high);
g_variant_unref(gvar);
if (i)
printf(", ");
printf("%"PRIu64"-%"PRIu64, low, high);
if (low == cur_low && high == cur_high)
printf(" (current)");
}
printf("\n");
g_variant_unref(gvar_list);
} else if (srci->datatype == SR_T_BOOL) {
printf(" %s: ", srci->id);
if (sr_config_get(sdi->driver, sdi, NULL, srci->key,
&gvar) == SR_OK) {
if (g_variant_get_boolean(gvar))
printf("on (current), off\n");
else
printf("on, off (current)\n");
g_variant_unref(gvar);
} else
printf("on, off\n");
} else if (srci->datatype == SR_T_DOUBLE_RANGE) {
printf(" %s: ", srci->id);
if (sr_config_list(sdi->driver, sdi, channel_group, srci->key,
&gvar_list) != SR_OK) {
printf("\n");
continue;
}
if (sr_config_get(sdi->driver, sdi, NULL, srci->key, &gvar) == SR_OK) {
g_variant_get(gvar, "(dd)", &dcur_low, &dcur_high);
g_variant_unref(gvar);
} else {
dcur_low = 0;
dcur_high = 0;
}
num_elements = g_variant_n_children(gvar_list);
for (i = 0; i < num_elements; i++) {
gvar = g_variant_get_child_value(gvar_list, i);
g_variant_get(gvar, "(dd)", &dlow, &dhigh);
g_variant_unref(gvar);
if (i)
printf(", ");
printf("%.1f-%.1f", dlow, dhigh);
if (dlow == dcur_low && dhigh == dcur_high)
printf(" (current)");
}
printf("\n");
g_variant_unref(gvar_list);
} else {
/* Everything else */
printf(" %s\n", srci->id);
}
}
g_variant_unref(gvar_opts);
sr_dev_close(sdi);
g_slist_free(devices);
}
static const gchar *
_evhelpers_token_list_callback(const gchar *token, guint64 value, gpointer user_data)
{
FormatStringReplaceData *data = user_data;
if ( data->callback != NULL )
return data->callback(token, data->event, data->user_data);
g_free(data->to_free);
data->to_free = NULL;
GVariant *content;
content = eventd_event_get_data(data->event, token);
if ( content == NULL )
return NULL;
if ( g_variant_is_of_type(content, G_VARIANT_TYPE_STRING) )
return g_variant_get_string(content, NULL);
if ( g_variant_is_of_type(content, G_VARIANT_TYPE_BOOLEAN) )
return g_variant_get_boolean(content) ? "true" : NULL;
#define _evhelpers_check_type_with_format(l, U, GFormat) G_STMT_START { \
if ( g_variant_is_of_type(content, G_VARIANT_TYPE_##U) ) \
{ \
g_snprintf(data->number, sizeof(data->number), "%" GFormat, g_variant_get_##l(content)); \
return data->number; \
} \
} G_STMT_END
#define _evhelpers_check_type(l, U) _evhelpers_check_type_with_format(l, U, G_G##U##_FORMAT)
_evhelpers_check_type(int16, INT16);
_evhelpers_check_type(int32, INT32);
_evhelpers_check_type(int64, INT64);
_evhelpers_check_type_with_format(byte, BYTE, "hhu");
_evhelpers_check_type(uint16, UINT16);
_evhelpers_check_type(uint32, UINT32);
_evhelpers_check_type(uint64, UINT64);
_evhelpers_check_type_with_format(double, DOUBLE, "lf");
#undef _evhelpers_check_type
#undef _evhelpers_check_type_with_format
if ( g_variant_is_of_type(content, G_VARIANT_TYPE_STRING_ARRAY) )
{
const gchar **strv;
gsize length;
GString *ret;
strv = g_variant_get_strv(content, &length);
if ( length > 0 )
{
ret = g_string_sized_new(length * strlen(strv[0]));
for ( ; *strv != NULL ; ++strv )
g_string_append_c(g_string_append(ret, *strv), ' ');
g_string_truncate(ret, ret->len - 1);
data->to_free = g_string_free(ret, FALSE);
}
}
else
data->to_free = g_variant_print(content, FALSE);
return data->to_free;
}
CCSSettingValue *
ccsGSettingsIntegratedSettingReadValue (CCSIntegratedSetting *setting, CCSSettingType type)
{
CCSGSettingsIntegratedSettingPrivate *priv = (CCSGSettingsIntegratedSettingPrivate *) ccsObjectGetPrivate (setting);
CCSSettingValue *v = calloc (1, sizeof (CCSSettingValue));
const char *gnomeKeyName = ccsGNOMEIntegratedSettingInfoGetGNOMEName ((CCSGNOMEIntegratedSettingInfo *) setting);
char *gsettingsTranslatedName = ccsGSettingsIntegratedSettingsTranslateOldGNOMEKeyForGSettings (gnomeKeyName);
v->isListChild = FALSE;
v->parent = NULL;
v->refCount = 1;
GVariant *variant = ccsGSettingsWrapperGetValue (priv->wrapper, gsettingsTranslatedName);
if (!variant)
{
free (gsettingsTranslatedName);
free (v);
return NULL;
}
const GVariantType *variantType = G_VARIANT_TYPE (g_variant_get_type_string (variant));
switch (type)
{
case TypeInt:
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE_INT32))
{
ccsError ("Expected integer value");
free (v);
v = NULL;
break;
}
v->value.asInt = readIntFromVariant (variant);
break;
case TypeBool:
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE_BOOLEAN))
{
ccsError ("Expected boolean value");
free (v);
v = NULL;
break;
}
v->value.asBool = readBoolFromVariant (variant);
break;
case TypeString:
{
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE_STRING))
{
ccsError ("Expected string value");
free (v);
v = NULL;
break;
}
const char *str = readStringFromVariant (variant);
v->value.asString = strdup (str ? str : "");
break;
}
case TypeKey:
{
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE ("as")))
{
ccsError ("Expected array-of-string value");
free (v);
v = NULL;
break;
}
gsize len;
const gchar **strv = g_variant_get_strv (variant, &len);
if (strv)
v->value.asString = strdup (strv[0] ? strv[0] : "");
else
v->value.asString = strdup ("");
g_free (strv);
break;
}
default:
g_assert_not_reached ();
}
g_variant_unref (variant);
free (gsettingsTranslatedName);
return v;
}
static void
on_localed_properties_changed (GDBusProxy *proxy,
GVariant *changed_properties,
const gchar **invalidated_properties,
GtkBuilder *dialog)
{
GVariant *v;
GtkWidget *label;
const char *layout;
char **layouts;
GString *disp;
guint i;
if (invalidated_properties != NULL) {
guint i;
for (i = 0; invalidated_properties[i] != NULL; i++) {
if (g_str_equal (invalidated_properties[i], "Locale"))
update_property (proxy, "Locale");
else if (g_str_equal (invalidated_properties[i], "X11Layout"))
update_property (proxy, "X11Layout");
}
}
v = g_dbus_proxy_get_cached_property (proxy, "Locale");
if (v) {
const gchar **strv;
gsize len;
gint i;
const gchar *lang, *messages, *time;
gchar *name;
GtkWidget *label;
strv = g_variant_get_strv (v, &len);
lang = messages = time = NULL;
for (i = 0; strv[i]; i++) {
if (g_str_has_prefix (strv[i], "LANG=")) {
lang = strv[i] + strlen ("LANG=");
}
else if (g_str_has_prefix (strv[i], "LC_MESSAGES=")) {
messages = strv[i] + strlen ("LC_MESSAGES=");
}
else if (g_str_has_prefix (strv[i], "LC_TIME=")) {
time = strv[i] + strlen ("LC_TIME=");
}
}
if (!messages) {
messages = lang;
}
if (!time) {
time = lang;
}
if (messages) {
name = gdm_get_language_from_name (messages, NULL);
label = WID ("system_display_language");
gtk_label_set_text (GTK_LABEL (label), name);
g_free (name);
g_object_set_data_full (G_OBJECT (label), "language", g_strdup (lang), g_free);
}
if (time) {
name = gdm_get_region_from_name (time, NULL);
label = WID ("system_format");
gtk_label_set_text (GTK_LABEL (label), name);
g_free (name);
g_object_set_data_full (G_OBJECT (label), "region", g_strdup (time), g_free);
}
g_variant_unref (v);
}
label = WID ("system_input_source");
v = g_dbus_proxy_get_cached_property (proxy, "X11Layout");
if (v) {
layout = g_variant_get_string (v, NULL);
g_object_set_data_full (G_OBJECT (label), "input_source", g_strdup (layout), g_free);
} else {
g_object_set_data_full (G_OBJECT (label), "input_source", NULL, g_free);
update_copy_button (dialog);
return;
}
disp = g_string_new ("");
layouts = g_strsplit (layout, ",", -1);
for (i = 0; layouts[i]; i++) {
gchar *utf_visible;
utf_visible = xkb_layout_description_utf8 (layouts[i]);
if (disp->str[0] != '\0')
disp = g_string_append (disp, ", ");
disp = g_string_append (disp, utf_visible ? utf_visible : layouts[i]);
g_free (utf_visible);
}
gtk_label_set_text (GTK_LABEL (label), disp->str);
g_string_free (disp, TRUE);
g_variant_unref (v);
update_copy_button (dialog);
}
/*
* Parse a filename pattern and replace markers with values from a TrackDetails
* structure.
*
* Valid markers so far are:
* %at -- album title
* %aa -- album artist
* %aA -- album artist (lowercase)
* %as -- album artist sortname
* %aS -- album artist sortname (lowercase)
* %ay -- album year
* %ag -- album genre
* %aG -- album genre (lowercase)
* %an -- album disc number
* %aN -- album disc number, zero padded
* %tn -- track number (i.e 8)
* %tN -- track number, zero padded (i.e 08)
* %tt -- track title
* %ta -- track artist
* %tA -- track artist (lowercase)
* %ts -- track artist sortname
* %tS -- track artist sortname (lowercase)
* %td -- track duration
* %te -- track elapsed time
* %tb -- track bitrate
* %st -- stream title
*/
static char *
parse_pattern (const char *pattern, GHashTable *properties, gint64 elapsed)
{
/* p is the pattern iterator, i is a general purpose iterator */
const char *p;
char *temp;
GString *s;
if (pattern == NULL || pattern[0] == 0)
return g_strdup (" ");
s = g_string_new (NULL);
p = pattern;
while (*p) {
char *string = NULL;
const char **strv = NULL;
GVariant *value = NULL;
/* If not a % marker, copy and continue */
if (*p != '%') {
g_string_append_c (s, *p++);
/* Explicit increment as we continue past the increment */
continue;
}
/* Is a % marker, go to next and see what to do */
switch (*++p) {
case '%':
/*
* Literal %
*/
g_string_append_c (s, '%');
break;
case 'a':
/*
* Album tag
*/
switch (*++p) {
case 't':
value = g_hash_table_lookup (properties, "xesam:album");
if (value)
string = g_variant_dup_string (value, NULL);
break;
case 'T':
value = g_hash_table_lookup (properties, "xesam:album");
if (value)
string = g_utf8_strdown (g_variant_get_string (value, NULL), -1);
break;
case 'a':
value = g_hash_table_lookup (properties, "xesam:artist");
if (value) {
strv = g_variant_get_strv (value, NULL);
string = g_strdup (strv[0]);
}
break;
case 'A':
value = g_hash_table_lookup (properties, "xesam:artist");
if (value) {
strv = g_variant_get_strv (value, NULL);
string = g_utf8_strdown (strv[0], -1);
}
break;
case 's':
value = g_hash_table_lookup (properties, "rhythmbox:albumArtistSortname");
if (value)
string = g_variant_dup_string (value, NULL);
break;
case 'S':
value = g_hash_table_lookup (properties, "rhythmbox:albumArtistSortname");
if (value)
string = g_utf8_strdown (g_variant_get_string (value, NULL), -1);
break;
case 'y':
/* Release year */
value = g_hash_table_lookup (properties, "xesam:contentCreated");
if (value) {
const char *iso8601;
GTimeVal tv;
iso8601 = g_variant_get_string (value, NULL);
if (g_time_val_from_iso8601 (iso8601, &tv)) {
GDate d;
g_date_set_time_val (&d, &tv);
string = g_strdup_printf ("%u", g_date_get_year (&d));
}
}
break;
/* Disc number */
case 'n':
value = g_hash_table_lookup (properties, "xesam:discNumber");
if (value)
string = g_strdup_printf ("%u", g_variant_get_int32 (value));
break;
case 'N':
value = g_hash_table_lookup (properties, "xesam:discNumber");
if (value)
string = g_strdup_printf ("%02u", g_variant_get_int32 (value));
break;
/* genre */
case 'g':
value = g_hash_table_lookup (properties, "xesam:genre");
if (value) {
strv = g_variant_get_strv (value, NULL);
string = g_strdup (strv[0]);
}
break;
case 'G':
value = g_hash_table_lookup (properties, "xesam:genre");
if (value) {
strv = g_variant_get_strv (value, NULL);
string = g_utf8_strdown (strv[0], -1);
}
break;
default:
string = g_strdup_printf ("%%a%c", *p);
}
break;
case 't':
/*
* Track tag
*/
switch (*++p) {
case 't':
value = g_hash_table_lookup (properties, "rhythmbox:streamTitle");
if (value == NULL)
value = g_hash_table_lookup (properties, "xesam:title");
if (value)
string = g_variant_dup_string (value, NULL);
break;
case 'T':
value = g_hash_table_lookup (properties, "rhythmbox:streamTitle");
if (value == NULL)
value = g_hash_table_lookup (properties, "xesam:title");
if (value)
string = g_utf8_strdown (g_variant_get_string (value, NULL), -1);
break;
case 'a':
value = g_hash_table_lookup (properties, "xesam:artist");
if (value) {
strv = g_variant_get_strv (value, NULL);
string = g_strdup (strv[0]);
}
break;
case 'A':
value = g_hash_table_lookup (properties, "xesam:artist");
if (value) {
strv = g_variant_get_strv (value, NULL);
string = g_utf8_strdown (strv[0], -1);
}
break;
case 's':
value = g_hash_table_lookup (properties, "rhythmbox:artistSortname");
if (value)
string = g_variant_dup_string (value, NULL);
break;
case 'S':
value = g_hash_table_lookup (properties, "rhythmbox:artistSortname");
if (value)
string = g_utf8_strdown (g_variant_get_string (value, NULL), -1);
break;
case 'n':
/* Track number */
value = g_hash_table_lookup (properties, "xesam:trackNumber");
if (value)
string = g_strdup_printf ("%u", g_variant_get_int32 (value));
break;
case 'N':
/* Track number, zero-padded */
value = g_hash_table_lookup (properties, "xesam:trackNumber");
if (value)
string = g_strdup_printf ("%02u", g_variant_get_int32 (value));
break;
case 'd':
/* Track duration */
value = g_hash_table_lookup (properties, "mpris:length");
if (value)
string = rb_make_duration_string (g_variant_get_int64 (value));
break;
case 'e':
/* Track elapsed time */
string = rb_make_duration_string (elapsed);
break;
case 'b':
/* Track bitrate */
value = g_hash_table_lookup (properties, "xesam:audioBitrate");
if (value)
string = g_strdup_printf ("%u", g_variant_get_int32 (value) / 1024);
break;
default:
string = g_strdup_printf ("%%t%c", *p);
}
break;
case 's':
/*
* Stream tag
*/
switch (*++p) {
case 't':
value = g_hash_table_lookup (properties, "rhythmbox:streamTitle");
if (value) {
value = g_hash_table_lookup (properties, "xesam:title");
if (value) {
string = g_variant_dup_string (value, NULL);
}
}
break;
default:
string = g_strdup_printf ("%%s%c", *p);
}
break;
default:
string = g_strdup_printf ("%%%c", *p);
}
if (string)
g_string_append (s, string);
g_free (string);
++p;
}
temp = s->str;
g_string_free (s, FALSE);
return temp;
}
