static gboolean
service_encode_aes_secret (SecretSession *session,
SecretValue *value,
GVariantBuilder *builder)
{
gcry_cipher_hd_t cih;
guchar *padded;
gsize n_padded, pos;
gcry_error_t gcry;
gpointer iv;
gconstpointer secret;
gsize n_secret;
GVariant *child;
g_variant_builder_add (builder, "o", session->path);
/* Create the cipher */
gcry = gcry_cipher_open (&cih, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CBC, 0);
if (gcry != 0) {
g_warning ("couldn't create AES cipher: %s", gcry_strerror (gcry));
return FALSE;
}
secret = secret_value_get (value, &n_secret);
/* Perform the encoding here */
padded = pkcs7_pad_bytes_in_secure_memory (secret, n_secret, &n_padded);
g_assert (padded != NULL);
/* Setup the IV */
iv = g_malloc0 (16);
gcry_create_nonce (iv, 16);
gcry = gcry_cipher_setiv (cih, iv, 16);
g_return_val_if_fail (gcry == 0, FALSE);
/* Setup the key */
gcry = gcry_cipher_setkey (cih, session->key, session->n_key);
g_return_val_if_fail (gcry == 0, FALSE);
/* Perform the encryption */
for (pos = 0; pos < n_padded; pos += 16) {
gcry = gcry_cipher_encrypt (cih, (guchar*)padded + pos, 16, NULL, 0);
g_return_val_if_fail (gcry == 0, FALSE);
}
gcry_cipher_close (cih);
child = g_variant_new_from_data (G_VARIANT_TYPE ("ay"), iv, 16, TRUE, g_free, iv);
g_variant_builder_add_value (builder, child);
child = g_variant_new_from_data (G_VARIANT_TYPE ("ay"), padded, n_padded, TRUE, egg_secure_free, padded);
g_variant_builder_add_value (builder, child);
g_variant_builder_add (builder, "s", secret_value_get_content_type (value));
return TRUE;
}
static int config_list(uint32_t key, GVariant **data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
GVariantBuilder gvb;
int ret;
/* Always available. */
if (key == SR_CONF_SCAN_OPTIONS) {
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
return SR_OK;
}
if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
return SR_OK;
}
if (!sdi)
return SR_ERR_ARG;
ret = SR_OK;
if (!cg) {
/* No channel group: global options. */
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
default:
return SR_ERR_NA;
}
} else {
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(uint32_t));
break;
case SR_CONF_CURRENT_LIMIT:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
/* Min, max, step. */
g_variant_builder_add_value(&gvb, g_variant_new_double(0.0));
g_variant_builder_add_value(&gvb, g_variant_new_double(6.0));
g_variant_builder_add_value(&gvb, g_variant_new_double(0.001)); /* 1mA steps */
*data = g_variant_builder_end(&gvb);
break;
default:
return SR_ERR_NA;
}
}
return ret;
}
static void ListSkins(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)
{
GVariantBuilder *ret = g_variant_builder_new(G_VARIANT_TYPE("(ia(iss))"));
g_variant_builder_add(ret, "i", 900);
GVariantBuilder *array = g_variant_builder_new(G_VARIANT_TYPE("a(iss)"));
for (cSkin* skin = Skins.First(); skin; skin = Skins.Next(skin))
g_variant_builder_add_value(array, BuildSkin(skin));
g_variant_builder_add_value(ret, g_variant_builder_end(array));
g_dbus_method_invocation_return_value(Invocation, g_variant_builder_end(ret));
g_variant_builder_unref(array);
g_variant_builder_unref(ret);
};
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
{
GVariant *tuple, *rational[2];
GVariantBuilder gvb;
unsigned int i;
struct dev_context *devc;
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
hwopts, ARRAY_SIZE(hwopts), sizeof(int32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
break;
case SR_CONF_COUPLING:
*data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
break;
case SR_CONF_VDIV:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
rational[0] = g_variant_new_uint64(vdivs[i][0]);
rational[1] = g_variant_new_uint64(vdivs[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TIMEBASE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(timebases); i++) {
rational[0] = g_variant_new_uint64(timebases[i][0]);
rational[1] = g_variant_new_uint64(timebases[i][1]);
tuple = g_variant_new_tuple(rational, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_SOURCE:
if (!sdi || !sdi->priv)
/* Can't know this until we have the exact model. */
return SR_ERR_ARG;
devc = sdi->priv;
*data = g_variant_new_strv(trigger_sources,
devc->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static void sReturnError(GDBusMethodInvocation *Invocation, int ReplyCode, const char *ReplyMessage)
{
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("(isaa(sv))"));
g_variant_builder_add(builder, "i", ReplyCode);
g_variant_builder_add(builder, "s", ReplyMessage);
GVariantBuilder *array = g_variant_builder_new(G_VARIANT_TYPE("aa(sv)"));
GVariantBuilder *innerArray = g_variant_builder_new(G_VARIANT_TYPE("a(sv)"));
g_variant_builder_add_value(array, g_variant_builder_end(innerArray));
g_variant_builder_add_value(builder, g_variant_builder_end(array));
g_dbus_method_invocation_return_value(Invocation, g_variant_builder_end(builder));
g_variant_builder_unref(innerArray);
g_variant_builder_unref(array);
g_variant_builder_unref(builder);
};
void cDBusHelper::AddKeyValue(GVariantBuilder *Array, const char *Key, const gchar *Type, void **Value)
{
GVariantBuilder *element = g_variant_builder_new(G_VARIANT_TYPE("(sv)"));
g_variant_builder_add(element, "s", Key);
GVariantBuilder *variant = g_variant_builder_new(G_VARIANT_TYPE("v"));
g_variant_builder_add(variant, Type, *Value);
g_variant_builder_add_value(element, g_variant_builder_end(variant));
g_variant_builder_add_value(Array, g_variant_builder_end(element));
g_variant_builder_unref(variant);
g_variant_builder_unref(element);
}
void
cb_cpu_color_changed (GsmColorButton *cp, gpointer data)
{
guint cpu_i = GPOINTER_TO_UINT (data);
auto settings = Gio::Settings::create (GSM_GSETTINGS_SCHEMA);
/* Get current values */
GVariant *cpu_colors_var = g_settings_get_value (settings->gobj(), GSM_SETTING_CPU_COLORS);
gsize children_n = g_variant_n_children(cpu_colors_var);
/* Create builder to contruct new setting with updated value for cpu i */
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
for (guint i = 0; i < children_n; i++) {
if(cpu_i == i) {
gchar *color;
GdkRGBA button_color;
gsm_color_button_get_color(cp, &button_color);
color = gdk_rgba_to_string (&button_color);
g_variant_builder_add(&builder, "(us)", i, color);
g_free (color);
} else {
g_variant_builder_add_value(&builder,
g_variant_get_child_value(cpu_colors_var, i));
}
}
/* Just set the value and let the changed::cpu-colors signal callback do the rest. */
settings->set_value (GSM_SETTING_CPU_COLORS, Glib::wrap (g_variant_builder_end(&builder)));
}
static int
app_launch (gchar **args)
{
GVariantBuilder files;
gint i;
if (!app_check_name (args, "launch"))
return 1;
if (args[1] == NULL)
return app_activate (args[0]);
g_variant_builder_init (&files, G_VARIANT_TYPE_STRING_ARRAY);
for (i = 1; args[i]; i++)
{
GFile *file;
/* "This operation never fails" */
file = g_file_new_for_commandline_arg (args[i]);
g_variant_builder_add_value (&files, g_variant_new_take_string (g_file_get_uri (file)));
g_object_unref (file);
}
return app_call (args[0], "Open", g_variant_new ("(as@a{sv})", &files, app_get_platform_data ()));
}
void
cb_cpu_color_changed (GSMColorButton *cp, gpointer data)
{
guint cpu_i = GPOINTER_TO_UINT (data);
GSettings *settings = g_settings_new (GSM_GSETTINGS_SCHEMA);
/* Get current values */
GVariant *cpu_colors_var = g_settings_get_value(settings, "cpu-colors");
gsize children_n = g_variant_n_children(cpu_colors_var);
/* Create builder to contruct new setting with updated value for cpu i */
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
for (guint i = 0; i < children_n; i++) {
if(cpu_i == i) {
gchar color[24];
GdkColor button_color;
gsm_color_button_get_color(cp, &button_color);
g_snprintf(color, sizeof(color), "#%04x%04x%04x",
button_color.red, button_color.green, button_color.blue);
g_variant_builder_add(&builder, "(us)", i, color);
} else {
g_variant_builder_add_value(&builder,
g_variant_get_child_value(cpu_colors_var, i));
}
}
/* Just set the value and let the changed::cpu-colors signal callback do the rest. */
g_settings_set_value(settings, "cpu-colors", g_variant_builder_end(&builder));
}
void setItemShortcut(DbusmenuMenuitem *item, int jmodifiers, int x11keycode) {
char* xname = XKeysymToString((KeySym)x11keycode);
if (xname == NULL) {
// _logmsg(LOG_LEVEL_ERROR, "XKeysymToString returns null for x11keycode=%d", x11keycode);
return;
}
// _logmsg(LOG_LEVEL_INFO, "XKeysymToString returns %s for x11keycode=%d", xname, x11keycode);
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
if ((jmodifiers & SHIFT_MASK) != 0)
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_SHIFT);
if ((jmodifiers & CTRL_MASK) != 0)
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_CONTROL);
if ((jmodifiers & ALT_MASK) != 0)
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_ALT);
if ((jmodifiers & META_MASK) != 0)
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_SUPER);
g_variant_builder_add(&builder, "s", xname);
GVariant *insideArr = g_variant_builder_end(&builder);
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
g_variant_builder_add_value(&builder, insideArr);
GVariant *outsideArr = g_variant_builder_end(&builder);
dbusmenu_menuitem_property_set_variant(item, DBUSMENU_MENUITEM_PROP_SHORTCUT, outsideArr);
}
/* Controller1 interface callbacks */
static gboolean
korva_server_on_handle_get_devices (KorvaController1 *iface,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
KorvaServer *self = KORVA_SERVER (user_data);
GVariantBuilder *builder;
GVariant *result;
GList *it;
gboolean devices = FALSE;
korva_server_reset_timeout (self);
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
it = self->priv->backends;
while (it) {
KorvaBackend *backend = (KorvaBackend *) it->data;
if (korva_device_lister_get_device_count (backend->lister) > 0) {
devices = TRUE;
serialize_device_list_backend (backend, builder);
}
it = it->next;
}
/* Add empty hash if no devices found */
if (!devices) {
g_variant_builder_add_value (builder, g_variant_new ("a{sv}", NULL));
}
result = g_variant_builder_end (builder);
korva_controller1_complete_get_devices (iface, invocation, result);
return TRUE;
}
GVariant *
g_mount_spec_to_dbus_with_path (GMountSpec *spec,
const char *path)
{
GVariantBuilder builder;
GVariant *v;
int i;
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
for (i = 0; i < spec->items->len; i++)
{
GMountSpecItem *item = &g_array_index (spec->items, GMountSpecItem, i);
g_variant_builder_add_value (&builder, g_variant_new ("{sv}",
item->key,
g_variant_new_bytestring (item->value)));
}
v = g_variant_new ("(^aya{sv})",
path ? path : "",
&builder);
g_variant_builder_clear (&builder);
return v;
}
static void List(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)
{
if (g_strcmp0(g_dbus_method_invocation_get_interface_name(Invocation), DBUS_VDR_PLUGIN_INTERFACE) == 0)
esyslog("dbus2vdr: use of deprecated interface: 'List' should be called with the interface '%s'!", DBUS_VDR_PLUGINMANAGER_INTERFACE);
#define EMPTY(s) (s == NULL ? "" : s)
GVariantBuilder *array = g_variant_builder_new(G_VARIANT_TYPE("a(ss)"));
int index = 0;
do
{
cPlugin *plugin = cPluginManager::GetPlugin(index);
if (plugin == NULL)
break;
const char *name = plugin->Name();
const char *version = plugin->Version();
g_variant_builder_add(array, "(ss)", EMPTY(name), EMPTY(version));
index++;
} while (true);
#undef EMPTY
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("(a(ss))"));
g_variant_builder_add_value(builder, g_variant_builder_end(array));
g_dbus_method_invocation_return_value(Invocation, g_variant_builder_end(builder));
g_variant_builder_unref(array);
g_variant_builder_unref(builder);
}
static void ListExtraVideoDirectories(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)
{
int replyCode = 500;
cString replyMessage = "Missing extra-video-directories patch";
cStringList dirs;
#ifdef EXTRA_VIDEO_DIRECTORIES_PATCH
if (!LockExtraVideoDirectories(false)) {
replyCode = 550;
replyMessage = "Unable to lock extra video directory list";
}
else {
if (ExtraVideoDirectories.Size() == 0) {
replyCode = 550;
replyMessage = "no extra video directories in list";
}
else {
replyCode = 250;
replyMessage = "";
for (int i = 0; i < ExtraVideoDirectories.Size(); i++)
dirs.Append(strdup(ExtraVideoDirectories.At(i)));
}
UnlockExtraVideoDirectories();
}
#endif
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("(isas)"));
g_variant_builder_add(builder, "i", replyCode);
g_variant_builder_add(builder, "s", *replyMessage);
GVariantBuilder *array = g_variant_builder_new(G_VARIANT_TYPE("as"));
for (int i = 0; i < dirs.Size(); i++)
g_variant_builder_add(array, "s", dirs.At(i));
g_variant_builder_add_value(builder, g_variant_builder_end(array));
g_dbus_method_invocation_return_value(Invocation, g_variant_builder_end(builder));
g_variant_builder_unref(array);
g_variant_builder_unref(builder);
};
static GVariant *
create_translation_dict (GHashTable * ht_strings, const gchar * en)
{
GVariantBuilder array;
guint count = 0;
GList *l;
g_variant_builder_init (&array, G_VARIANT_TYPE_ARRAY);
for (l = langs; l != NULL; l = l->next) {
const gchar *trans, *lang;
lang = (const gchar *) l->data;
trans = g_hash_table_lookup (ht_strings, (gpointer) lang);
if (trans != NULL && *trans != '\0' && strcmp (en, trans) != 0 &&
!skip_translation (ht_strings, lang, trans)) {
/* g_print ("%s (%s) => %s\n", en, lang, trans); */
g_variant_builder_add_value (&array,
g_variant_new_dict_entry (g_variant_new_string (lang),
g_variant_new_string (trans)));
++count;
}
}
if (count == 0) {
g_variant_builder_clear (&array);
return NULL;
}
return g_variant_builder_end (&array);
}
/**
* dbusmenu_menuitem_property_set_shortcut:
* @menuitem: The #DbusmenuMenuitem to set the shortcut on
* @key: The keycode of the key to send
* @modifier: A bitmask of modifiers used to activate the item
*
* Takes the modifer described by @key and @modifier and places that into
* the format sending across Dbus for shortcuts.
*
* Return value: Whether it was successful at setting the property.
*/
gboolean
dbusmenu_menuitem_property_set_shortcut (DbusmenuMenuitem * menuitem, guint key, GdkModifierType modifier)
{
g_return_val_if_fail(DBUSMENU_IS_MENUITEM(menuitem), FALSE);
g_return_val_if_fail(gtk_accelerator_valid(key, modifier), FALSE);
const gchar * keyname = gdk_keyval_name(key);
g_return_val_if_fail(keyname != NULL, FALSE);
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
if (modifier & GDK_CONTROL_MASK) {
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_CONTROL);
}
if (modifier & GDK_MOD1_MASK) {
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_ALT);
}
if (modifier & GDK_SHIFT_MASK) {
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_SHIFT);
}
if (modifier & GDK_SUPER_MASK) {
g_variant_builder_add(&builder, "s", DBUSMENU_MENUITEM_SHORTCUT_SUPER);
}
g_variant_builder_add(&builder, "s", keyname);
GVariant * inside = g_variant_builder_end(&builder);
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
g_variant_builder_add_value(&builder, inside);
GVariant * outsidevariant = g_variant_builder_end(&builder);
return dbusmenu_menuitem_property_set_variant(menuitem, DBUSMENU_MENUITEM_PROP_SHORTCUT, outsidevariant);
}
static void
load_current_ready (MMIfaceModemFirmware *self,
GAsyncResult *res,
HandleListContext *ctx)
{
GVariantBuilder builder;
GList *l;
GError *error = NULL;
/* reported current may be NULL and we don't treat it as error */
ctx->current = MM_IFACE_MODEM_FIRMWARE_GET_INTERFACE (self)->load_current_finish (self, res, &error);
if (error) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_list_context_free (ctx);
return;
}
/* Build array of dicts */
g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
for (l = ctx->list; l; l = g_list_next (l))
g_variant_builder_add_value (
&builder,
mm_firmware_properties_get_dictionary (MM_FIRMWARE_PROPERTIES (l->data)));
mm_gdbus_modem_firmware_complete_list (
ctx->skeleton,
ctx->invocation,
(ctx->current ? mm_firmware_properties_get_unique_id (ctx->current) : ""),
g_variant_builder_end (&builder));
handle_list_context_free (ctx);
}
static void CurrentSkin(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)
{
GVariantBuilder *ret = g_variant_builder_new(G_VARIANT_TYPE("(i(iss))"));
g_variant_builder_add(ret, "i", 900);
g_variant_builder_add_value(ret, BuildSkin(Skins.Current()));
g_dbus_method_invocation_return_value(Invocation, g_variant_builder_end(ret));
g_variant_builder_unref(ret);
};
static void
serialize_device_list (gpointer data, gpointer user_data)
{
GVariantBuilder *builder = (GVariantBuilder *) user_data;
KorvaDevice *device = (KorvaDevice *) data;
g_variant_builder_add_value (builder,
korva_device_serialize (device));
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *tuple, *range[2];
GVariantBuilder gvb;
unsigned int i;
int ret;
(void)cg;
ret = SR_OK;
if (!sdi) {
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
break;
default:
return SR_ERR_NA;
}
} else {
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SPL_WEIGHT_FREQ:
*data = g_variant_new_strv(weight_freq, ARRAY_SIZE(weight_freq));
break;
case SR_CONF_SPL_WEIGHT_TIME:
*data = g_variant_new_strv(weight_time, ARRAY_SIZE(weight_time));
break;
case SR_CONF_SPL_MEASUREMENT_RANGE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (i = 0; i < ARRAY_SIZE(meas_ranges); i++) {
range[0] = g_variant_new_uint64(meas_ranges[i][0]);
range[1] = g_variant_new_uint64(meas_ranges[i][1]);
tuple = g_variant_new_tuple(range, 2);
g_variant_builder_add_value(&gvb, tuple);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_DATA_SOURCE:
*data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
break;
default:
return SR_ERR_NA;
}
}
return ret;
}
static void
manager_method_call (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
GDBusObjectManagerServer *manager = G_DBUS_OBJECT_MANAGER_SERVER (user_data);
GVariantBuilder array_builder;
GHashTableIter object_iter;
RegistrationData *data;
if (g_strcmp0 (method_name, "GetManagedObjects") == 0)
{
g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("a{oa{sa{sv}}}"));
g_hash_table_iter_init (&object_iter, manager->priv->map_object_path_to_data);
while (g_hash_table_iter_next (&object_iter, NULL, (gpointer) &data))
{
GVariantBuilder interfaces_builder;
GHashTableIter interface_iter;
GDBusInterfaceSkeleton *iface;
const gchar *iter_object_path;
g_variant_builder_init (&interfaces_builder, G_VARIANT_TYPE ("a{sa{sv}}"));
g_hash_table_iter_init (&interface_iter, data->map_iface_name_to_iface);
while (g_hash_table_iter_next (&interface_iter, NULL, (gpointer) &iface))
{
g_variant_builder_add_value (&interfaces_builder,
g_variant_new ("{s@a{sv}}",
g_dbus_interface_skeleton_get_info (iface)->name,
g_dbus_interface_skeleton_get_properties (iface)));
}
iter_object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object));
g_variant_builder_add (&array_builder,
"{oa{sa{sv}}}",
iter_object_path,
&interfaces_builder);
}
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(a{oa{sa{sv}}})",
&array_builder));
}
else
{
g_dbus_method_invocation_return_error (invocation,
G_DBUS_ERROR,
G_DBUS_ERROR_UNKNOWN_METHOD,
"Unknown method %s - only GetManagedObjects() is supported",
method_name);
}
}
static void List(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)
{
recordings.Update(true);
GVariantBuilder *array = g_variant_builder_new(G_VARIANT_TYPE("a(ia(sv))"));
for (cRecording *r = recordings.First(); r; r = recordings.Next(r))
g_variant_builder_add_value(array, BuildRecording(r));
GVariant *a = g_variant_builder_end(array);
g_dbus_method_invocation_return_value(Invocation, g_variant_new_tuple(&a, 1));
g_variant_builder_unref(array);
};
/**
* Convert an array of Scheme objects to a GVariant that serves as
* the primary parameter to g_dbus_proxy_call.
*/
static GVariant *
scheme_objects_to_parameter_tuple (gchar *fun,
int arity,
Scheme_Object **objects,
GDBusArgInfo *formals[])
{
int i; // Counter variable
GVariantBuilder *builder;
// Something to let us build tuples
GVariant *result; // The GVariant we build
GVariant *actual; // One actual
builder = g_variant_builder_new (G_VARIANT_TYPE_TUPLE);
// Annotations for garbage collector.
// Since we're converting Scheme_Object values to GVariants, it should
// not be the case that we have an "allocating call". However, I am
// worried that conversion to a string, which requires
// scheme_char_string_to_byte_string_locale, might be considered an
// allocating call. So let's be in the safe side. The sample code suggests
// that we can put an array of GObjects in a single variable (see
// the supplied makeadder3m.c for more details).
MZ_GC_DECL_REG (1);
MZ_GC_VAR_IN_REG (0, objects);
MZ_GC_REG ();
// Process all the parameters
for (i = 0; i < arity; i++)
{
actual = scheme_object_to_parameter (objects[i], formals[i]->signature);
// If we can't convert the parameter, we give up.
if (actual == NULL)
{
// Early exit - Clean up for garbage collection
MZ_GC_UNREG ();
// Get rid of the builder
g_variant_builder_unref (builder);
// And return an arror message.
scheme_wrong_type (fun,
dbus_signature_to_string (formals[i]->signature),
i,
arity,
objects);
} // If we could not convert
// Otherwise, we add the value to the builder and go on
g_variant_builder_add_value (builder, actual);
} // for
// Clean up garbage collection info.
MZ_GC_UNREG ();
// And we're done.
result = g_variant_builder_end (builder);
return result;
} // scheme_objects_to_parameter_tuple
/**
* _g_dbus_dbus_1_to_gvariant:
* @message: A #DBusMessage
* @error: Return location for error or %NULL.
*
* If @message is an error message (cf. DBUS_MESSAGE_TYPE_ERROR), sets
* @error with the contents of the error using
* g_dbus_error_set_dbus_error().
*
* Otherwise build a #GVariant with the message (this never fails).
*
* Returns: A #GVariant or %NULL if @error is set.
**/
GVariant *
_g_dbus_dbus_1_to_gvariant (DBusMessage *message,
GError **error)
{
DBusMessageIter iter;
GVariantBuilder *builder;
guint n;
GVariant *result;
DBusError dbus_error;
g_assert (message != NULL);
result = NULL;
dbus_error_init (&dbus_error);
if (dbus_set_error_from_message (&dbus_error, message))
{
g_dbus_error_set_dbus_error (error,
dbus_error.name,
dbus_error.message,
NULL);
dbus_error_free (&dbus_error);
goto out;
}
dbus_message_iter_init (message, &iter);
builder = g_variant_builder_new (G_VARIANT_TYPE_TUPLE);
n = 0;
while (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID)
{
GVariant *item;
item = dconf_dbus_to_gv (&iter, error);
if (item == NULL)
{
g_variant_builder_cancel (builder);
g_prefix_error (error,
_("Error decoding out-arg %d: "),
n);
goto out;
}
g_variant_builder_add_value (builder, item);
dbus_message_iter_next (&iter);
}
result = g_variant_builder_end (builder);
out:
return result;
}
GVariant*
_gba_to_gvariant(GByteArray *gba)
{
guint8 *b;
size_t i, max;
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (b=gba->data,max=gba->len,i=0; i<max ;i++)
g_variant_builder_add_value(builder, g_variant_new_byte(b[i]));
GVariant *result = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
return result;
}
static gboolean
get_result_metas_cb (GcalShellSearchProvider *search_provider,
GDBusMethodInvocation *invocation,
gchar **results,
GcalShellSearchProvider2 *skel)
{
GcalShellSearchProviderPrivate *priv;
GDateTime *local_datetime;
GVariantBuilder abuilder, builder;
GVariant *icon_variant;
GcalEvent *event;
GdkPixbuf *gicon;
gchar *uuid, *desc;
gchar *start_date;
gint i;
priv = search_provider->priv;
g_variant_builder_init (&abuilder, G_VARIANT_TYPE ("aa{sv}"));
for (i = 0; i < g_strv_length (results); i++)
{
uuid = results[i];
event = g_hash_table_lookup (priv->events, uuid);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&builder, "{sv}", "id", g_variant_new_string (uuid));
g_variant_builder_add (&builder, "{sv}", "name", g_variant_new_string (gcal_event_get_summary (event)));
gicon = get_circle_pixbuf_from_color (gcal_event_get_color (event), 128);
icon_variant = g_icon_serialize (G_ICON (gicon));
g_variant_builder_add (&builder, "{sv}", "icon", icon_variant);
g_object_unref (gicon);
g_variant_unref (icon_variant);
local_datetime = g_date_time_to_local (gcal_event_get_date_start (event));
/* FIXME: respect 24h time format */
start_date = g_date_time_format (local_datetime, gcal_event_get_all_day (event) ? "%x" : "%c");
if (gcal_event_get_location (event))
desc = g_strconcat (start_date, ". ", gcal_event_get_location (event), NULL);
else
desc = g_strdup (start_date);
g_variant_builder_add (&builder, "{sv}", "description", g_variant_new_string (desc));
g_variant_builder_add_value (&abuilder, g_variant_builder_end (&builder));
}
g_dbus_method_invocation_return_value (invocation, g_variant_new ("(aa{sv})", &abuilder));
return TRUE;
}
static gboolean
service_encode_plain_secret (SecretSession *session,
SecretValue *value,
GVariantBuilder *builder)
{
gconstpointer secret;
gsize n_secret;
GVariant *child;
g_variant_builder_add (builder, "o", session->path);
secret = secret_value_get (value, &n_secret);
child = g_variant_new_from_data (G_VARIANT_TYPE ("ay"), "", 0, TRUE, NULL, NULL);
g_variant_builder_add_value (builder, child);
child = g_variant_new_from_data (G_VARIANT_TYPE ("ay"), secret, n_secret, TRUE,
secret_value_unref, secret_value_ref (value));
g_variant_builder_add_value (builder, child);
g_variant_builder_add (builder, "s", secret_value_get_content_type (value));
return TRUE;
}
static void _dbus_geany_dbus_application_new_document (GeanyDBusApplication* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
GError* error;
gboolean result;
GVariantIter _arguments_iter;
GVariant* _reply;
GVariantBuilder _reply_builder;
error = NULL;
g_variant_iter_init (&_arguments_iter, parameters);
result = geany_dbus_application_new_document (self);
g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
_reply = g_variant_builder_end (&_reply_builder);
g_dbus_method_invocation_return_value (invocation, _reply);
}
static GVariant *
g_menu_exporter_menu_list (GMenuExporterMenu *menu)
{
GVariantBuilder builder;
gint i, n;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("aa{sv}"));
n = g_sequence_get_length (menu->item_links);
for (i = 0; i < n; i++)
g_variant_builder_add_value (&builder, g_menu_exporter_menu_describe_item (menu, i));
return g_variant_builder_end (&builder);
}
GVariant*
_gb_to_gvariant(GBytes *gb)
{
gsize max;
gconstpointer b = g_bytes_get_data(gb, &max);
const guint8 *b8 = b;
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (gsize i=0; i<max ;i++)
g_variant_builder_add_value(builder, g_variant_new_byte(b8[i]));
GVariant *result = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
return result;
}
