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;
}
/**
* terminal_client_append_exec_options:
* @builder: a #GVariantBuilder of #GVariantType "a{sv}"
* @working_directory: (allow-none): the cwd, or %NULL
* @shell:
*
* Appends the environment and the working directory to @builder.
*/
void
terminal_client_append_exec_options (GVariantBuilder *builder,
const char *working_directory,
gboolean shell)
{
gs_strfreev char **envv;
envv = g_get_environ ();
envv = g_environ_unsetenv (envv, "COLORTERM");
envv = g_environ_unsetenv (envv, "COLUMNS");
envv = g_environ_unsetenv (envv, "DESKTOP_STARTUP_ID");
envv = g_environ_unsetenv (envv, "DISPLAY");
envv = g_environ_unsetenv (envv, "GIO_LAUNCHED_DESKTOP_FILE_PID");
envv = g_environ_unsetenv (envv, "GIO_LAUNCHED_DESKTOP_FILE");
envv = g_environ_unsetenv (envv, "GNOME_DESKTOP_ICON");
envv = g_environ_unsetenv (envv, "LINES");
envv = g_environ_unsetenv (envv, "PWD");
envv = g_environ_unsetenv (envv, "TERM");
envv = g_environ_unsetenv (envv, "WINDOWID");
g_variant_builder_add (builder, "{sv}",
"environ",
g_variant_new_bytestring_array ((const char * const *) envv, -1));
if (working_directory)
g_variant_builder_add (builder, "{sv}",
"cwd", g_variant_new_bytestring (working_directory));
if (shell)
g_variant_builder_add (builder, "{sv}",
"shell",
g_variant_new_boolean (TRUE));
}
static GVariant *
translate_kerberos_credentials (GVariant *creds)
{
gchar *type;
gchar *arg1;
gchar *arg2;
g_variant_get (creds, "(&s&s&s)", &type, &arg1, &arg2);
if (strcmp (type, "user") == 0)
{
return g_variant_new ("(ssv)",
"password", "user", g_variant_new ("(ss)", arg1, arg2));
}
else if (strcmp (type, "admin") == 0)
{
return g_variant_new ("(ssv)",
"password", "administrator", g_variant_new ("(ss)", arg1, arg2));
}
else if (strcmp (type, "otp") == 0)
{
return g_variant_new ("(ssv)",
"secret", "none", g_variant_new_bytestring (arg1));
}
else if (strcmp (type, "none") == 0)
{
return g_variant_new ("(ssv)",
"automatic", "none", g_variant_new ("s", ""));
}
else
return NULL;
}
static void
change_passphrase_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
ChangePassphraseData *data = user_data;
GError *error;
error = NULL;
if (!udisks_encrypted_call_change_passphrase_finish (UDISKS_ENCRYPTED (source_object),
res,
&error))
{
gdu_utils_show_error (GTK_WINDOW (data->window), _("Error changing passphrase"), error);
g_error_free (error);
}
/* Update the system-level configuration, if applicable */
if (data->has_passphrase_in_configuration)
{
GVariantBuilder builder;
GVariantIter iter;
const gchar *key;
GVariant *value;
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_iter_init (&iter, data->crypttab_details);
while (g_variant_iter_next (&iter, "{sv}", &key, &value))
{
if (g_strcmp0 (key, "passphrase-contents") == 0)
{
g_variant_builder_add (&builder, "{sv}", "passphrase-contents",
g_variant_new_bytestring (gtk_entry_get_text (GTK_ENTRY (data->passphrase_entry))));
}
else
{
g_variant_builder_add (&builder, "{sv}", key, value);
}
g_variant_unref (value);
}
udisks_block_call_update_configuration_item (data->block,
g_variant_new ("(s@a{sv})", "crypttab", data->crypttab_details),
g_variant_new ("(sa{sv})", "crypttab", &builder),
g_variant_new ("a{sv}", NULL), /* options */
NULL, /* cancellable */
update_configuration_item_cb,
data);
}
else
{
change_passphrase_data_free (data);
}
}
/**
* terminal_client_append_create_instance_options:
* @builder: a #GVariantBuilder of #GVariantType "a{sv}"
* @display: (array element-type=guint8):
* @startup_id: (array element-type=guint8):
* @geometry:
* @role:
* @profile:
* @title:
* @maximise_window:
* @fullscreen_window:
*
* Appends common options to @builder.
*/
void
terminal_client_append_create_instance_options (GVariantBuilder *builder,
const char *display_name,
const char *startup_id,
const char *geometry,
const char *role,
const char *profile,
const char *title,
gboolean maximise_window,
gboolean fullscreen_window)
{
/* Bytestring options */
g_variant_builder_add (builder, "{sv}",
"display", g_variant_new_bytestring (display_name));
if (startup_id)
g_variant_builder_add (builder, "{sv}",
"desktop-startup-id", g_variant_new_bytestring (startup_id));
/* String options */
if (profile)
g_variant_builder_add (builder, "{sv}",
"profile", g_variant_new_string (profile));
if (title)
g_variant_builder_add (builder, "{sv}",
"title", g_variant_new_string (title));
if (geometry)
g_variant_builder_add (builder, "{sv}",
"geometry", g_variant_new_string (geometry));
if (role)
g_variant_builder_add (builder, "{sv}",
"role", g_variant_new_string (role));
/* Boolean options */
if (maximise_window)
g_variant_builder_add (builder, "{sv}",
"maximize-window", g_variant_new_boolean (TRUE));
if (fullscreen_window)
g_variant_builder_add (builder, "{sv}",
"fullscreen-window", g_variant_new_boolean (TRUE));
}
GVariant *convertVariant(const QVariant &variant)
{
switch (variant.type()) {
case QVariant::Bool:
return g_variant_new_boolean(variant.toBool());
case QVariant::Char:
return g_variant_new_byte(variant.toChar().toLatin1());
case QVariant::Int:
return g_variant_new_int32(variant.toInt());
case QVariant::UInt:
return g_variant_new_uint32(variant.toUInt());
case QVariant::LongLong:
return g_variant_new_int64(variant.toLongLong());
case QVariant::ULongLong:
return g_variant_new_uint64(variant.toULongLong());
case QVariant::Double:
return g_variant_new_double(variant.toDouble());
case QVariant::String:
return g_variant_new_string(variant.toString().toUtf8().constData());
case QVariant::StringList: {
QStringList value = variant.toStringList();
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
foreach (QString item ,value)
g_variant_builder_add(builder, "s", item.toUtf8().constData());
GVariant *result = g_variant_new("as", builder);
g_variant_builder_unref(builder);
return result;
}
case QVariant::ByteArray:
return g_variant_new_bytestring(variant.toByteArray().constData());
case QVariant::Url:
return g_variant_new_string(variant.toUrl().toString().toUtf8().constData());
case QVariant::Color:
return g_variant_new_string(variant.toString().toUtf8().constData());
default: {
#ifndef QT_NO_DATASTREAM
QByteArray a;
QDataStream s(&a, QIODevice::WriteOnly);
s.setVersion(QDataStream::Qt_4_0);
s << variant;
return g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING, a.constData(),
a.size(), TRUE, NULL, NULL);
#else
Q_ASSERT(!"QConfiguration: Cannot save custom types without QDataStream support");
#endif
}
}
return 0;
}
/**
* gtlm_nfc_write_username_password:
* @tlm_nfc: an instance of GTlmNfc object
* @nfc_tag_path: an identificator of the nfc tag (returned by #GTlmNfc::tag-found)
* @username: username to write
* @password: password to write
* @error: if non-NULL, set to an error, if one occurs
*
* This function is used to write a username and password to a tag. The tag path
* can be obtained by listening to #GTlmNfc::tag-found signals). @error is set to
* @GTLM_NFC_ERROR_NO_TAG if no such tag exists.
*/
void gtlm_nfc_write_username_password(GTlmNfc* tlm_nfc,
const gchar* nfc_tag_path,
const gchar* username,
const gchar* password,
GError** error)
{
if (nfc_tag_path == NULL) {
*error = g_error_new(GTLM_NFC_ERROR, GTLM_NFC_ERROR_NO_TAG, "No tag is present");
return;
}
GDBusProxy* tag = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL, /* GDBusInterfaceInfo */
"org.neard",
nfc_tag_path,
"org.neard.Tag",
NULL, /* GCancellable */
error);
if (tag == NULL) {
g_debug ("Error creating tag proxy: %s", (*error)->message);
return;
}
//gchar binary_data[] = {0x41, 0x42, 0x43, 0x44};
gchar* binary_data = _encode_username_password(username, password);
GVariant* payload = g_variant_new_bytestring(binary_data);
g_free(binary_data);
GVariant* arguments = g_variant_new_parsed ("({'Type': <'MIME'>, 'MIME': <'application/gtlm-nfc'>, 'Payload' : %v },)", payload);
GVariant *result = g_dbus_proxy_call_sync (tag,
"Write",
arguments,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
error);
if (result == NULL) {
g_debug ("Error writing to tag: %s", (*error)->message);
g_object_unref(tag);
return;
}
g_variant_unref(result);
g_object_unref(tag);
}
static gboolean
read_xattr_name_array (const char *path,
const char *xattrs,
size_t len,
GVariantBuilder *builder,
GError **error)
{
gboolean ret = FALSE;
const char *p;
p = xattrs;
while (p < xattrs+len)
{
ssize_t bytes_read;
char *buf;
bytes_read = lgetxattr (path, p, NULL, 0);
if (bytes_read < 0)
{
ot_util_set_error_from_errno (error, errno);
goto out;
}
if (bytes_read == 0)
continue;
buf = g_malloc (bytes_read);
if (lgetxattr (path, p, buf, bytes_read) < 0)
{
ot_util_set_error_from_errno (error, errno);
g_free (buf);
goto out;
}
g_variant_builder_add (builder, "(@ay@ay)",
g_variant_new_bytestring (p),
g_variant_new_from_data (G_VARIANT_TYPE ("ay"),
buf, bytes_read, FALSE, g_free, buf));
p = p + strlen (p) + 1;
}
ret = TRUE;
out:
return ret;
}
static gboolean hw_event_cb(GIOChannel *hw_io, GIOCondition condition,
gpointer userdata)
{
struct ofono_modem *modem = userdata;
struct telit_data *data = ofono_modem_get_data(modem);
if (condition & G_IO_IN) {
GIOStatus status;
gsize bytes_read, bytes_written;
gchar buf[300] = "";
status = g_io_channel_read_chars(hw_io, buf, 300,
&bytes_read, NULL);
if (bytes_read > 0) {
int cond = condition & G_IO_IN;
char buf_str[300 * 3 + 1] = { 0 };
char *endBuf = buf_str;
int i;
for (i = 0; i < bytes_read; i++) {
endBuf += sprintf(endBuf, "%02X ", (unsigned char)buf[i]);
}
DBG("read %zu bytes (cond %d): %s", bytes_read, cond, buf_str);
}
if (bytes_read > 0) {
g_io_channel_write_chars(data->bt_io, buf,
bytes_read, &bytes_written, NULL);
g_dbus_proxy_call (dbProxy, "ProcessAPDU",
g_variant_new_bytestring (buf), G_DBUS_CALL_FLAGS_NONE,
-1, NULL, (GAsyncReadyCallback) smartcard_cb, modem);
}
if (status != G_IO_STATUS_NORMAL && status != G_IO_STATUS_AGAIN)
return FALSE;
return TRUE;
}
return FALSE;
}
static void deja_dup_config_rel_path_real_write_to_config (DejaDupConfigEntry* base) {
DejaDupConfigRelPath * self;
GtkEntry* _tmp0_;
const gchar* _tmp1_ = NULL;
GVariant* _tmp2_;
GVariant* _tmp3_;
GVariant* val;
DejaDupSimpleSettings* _tmp4_;
const gchar* _tmp5_;
const gchar* _tmp6_;
self = (DejaDupConfigRelPath*) base;
_tmp0_ = ((DejaDupConfigEntry*) self)->entry;
_tmp1_ = gtk_entry_get_text (_tmp0_);
_tmp2_ = g_variant_new_bytestring (_tmp1_);
_tmp3_ = g_variant_ref_sink (_tmp2_);
val = _tmp3_;
_tmp4_ = ((DejaDupConfigWidget*) self)->settings;
_tmp5_ = deja_dup_config_widget_get_key ((DejaDupConfigWidget*) self);
_tmp6_ = _tmp5_;
deja_dup_simple_settings_set_value (_tmp4_, _tmp6_, val);
_g_variant_unref0 (val);
}
/**
* g_dbus_gvalue_to_gvariant:
* @gvalue: A #GValue to convert to a #GVariant
* @type: A #GVariantType
*
* Converts a #GValue to a #GVariant of the type indicated by the @type
* parameter.
*
* The conversion is using the following rules:
*
* - #G_TYPE_STRING: 's', 'o', 'g' or 'ay'
* - #G_TYPE_STRV: 'as', 'ao' or 'aay'
* - #G_TYPE_BOOLEAN: 'b'
* - #G_TYPE_UCHAR: 'y'
* - #G_TYPE_INT: 'i', 'n'
* - #G_TYPE_UINT: 'u', 'q'
* - #G_TYPE_INT64 'x'
* - #G_TYPE_UINT64: 't'
* - #G_TYPE_DOUBLE: 'd'
* - #G_TYPE_VARIANT: Any #GVariantType
*
* This can fail if e.g. @gvalue is of type #G_TYPE_STRING and @type
* is ['i'][G-VARIANT-TYPE-INT32:CAPS]. It will also fail for any #GType
* (including e.g. #G_TYPE_OBJECT and #G_TYPE_BOXED derived-types) not
* in the table above.
*
* Note that if @gvalue is of type #G_TYPE_VARIANT and its value is
* %NULL, the empty #GVariant instance (never %NULL) for @type is
* returned (e.g. 0 for scalar types, the empty string for string types,
* '/' for object path types, the empty array for any array type and so on).
*
* See the g_dbus_gvariant_to_gvalue() function for how to convert a
* #GVariant to a #GValue.
*
* Returns: A #GVariant (never floating) of #GVariantType @type holding
* the data from @gvalue or %NULL in case of failure. Free with
* g_variant_unref().
*
* Since: 2.30
*/
GVariant *
g_dbus_gvalue_to_gvariant (const GValue *gvalue,
const GVariantType *type)
{
GVariant *ret;
const gchar *s;
const gchar * const *as;
const gchar *empty_strv[1] = {NULL};
g_return_val_if_fail (gvalue != NULL, NULL);
g_return_val_if_fail (type != NULL, NULL);
ret = NULL;
/* @type can easily be e.g. "s" with the GValue holding a GVariant - for example this
* can happen when using the org.gtk.GDBus.C.ForceGVariant annotation with the
* gdbus-codegen(1) tool.
*/
if (G_VALUE_TYPE (gvalue) == G_TYPE_VARIANT)
{
ret = g_value_dup_variant (gvalue);
}
else
{
switch (g_variant_type_peek_string (type)[0])
{
case G_VARIANT_CLASS_BOOLEAN:
ret = g_variant_ref_sink (g_variant_new_boolean (g_value_get_boolean (gvalue)));
break;
case G_VARIANT_CLASS_BYTE:
ret = g_variant_ref_sink (g_variant_new_byte (g_value_get_uchar (gvalue)));
break;
case G_VARIANT_CLASS_INT16:
ret = g_variant_ref_sink (g_variant_new_int16 (g_value_get_int (gvalue)));
break;
case G_VARIANT_CLASS_UINT16:
ret = g_variant_ref_sink (g_variant_new_uint16 (g_value_get_uint (gvalue)));
break;
case G_VARIANT_CLASS_INT32:
ret = g_variant_ref_sink (g_variant_new_int32 (g_value_get_int (gvalue)));
break;
case G_VARIANT_CLASS_UINT32:
ret = g_variant_ref_sink (g_variant_new_uint32 (g_value_get_uint (gvalue)));
break;
case G_VARIANT_CLASS_INT64:
ret = g_variant_ref_sink (g_variant_new_int64 (g_value_get_int64 (gvalue)));
break;
case G_VARIANT_CLASS_UINT64:
ret = g_variant_ref_sink (g_variant_new_uint64 (g_value_get_uint64 (gvalue)));
break;
case G_VARIANT_CLASS_DOUBLE:
ret = g_variant_ref_sink (g_variant_new_double (g_value_get_double (gvalue)));
break;
case G_VARIANT_CLASS_STRING:
s = g_value_get_string (gvalue);
if (s == NULL)
s = "";
ret = g_variant_ref_sink (g_variant_new_string (s));
break;
case G_VARIANT_CLASS_OBJECT_PATH:
s = g_value_get_string (gvalue);
if (s == NULL)
s = "/";
ret = g_variant_ref_sink (g_variant_new_object_path (s));
break;
case G_VARIANT_CLASS_SIGNATURE:
s = g_value_get_string (gvalue);
if (s == NULL)
s = "";
ret = g_variant_ref_sink (g_variant_new_signature (s));
break;
case G_VARIANT_CLASS_ARRAY:
switch (g_variant_type_peek_string (type)[1])
{
case G_VARIANT_CLASS_BYTE:
s = g_value_get_string (gvalue);
if (s == NULL)
s = "";
ret = g_variant_ref_sink (g_variant_new_bytestring (s));
break;
case G_VARIANT_CLASS_STRING:
as = g_value_get_boxed (gvalue);
if (as == NULL)
as = empty_strv;
ret = g_variant_ref_sink (g_variant_new_strv (as, -1));
break;
case G_VARIANT_CLASS_OBJECT_PATH:
as = g_value_get_boxed (gvalue);
if (as == NULL)
as = empty_strv;
ret = g_variant_ref_sink (g_variant_new_objv (as, -1));
break;
case G_VARIANT_CLASS_ARRAY:
switch (g_variant_type_peek_string (type)[2])
{
case G_VARIANT_CLASS_BYTE:
as = g_value_get_boxed (gvalue);
if (as == NULL)
as = empty_strv;
ret = g_variant_ref_sink (g_variant_new_bytestring_array (as, -1));
break;
default:
ret = g_value_dup_variant (gvalue);
break;
}
break;
default:
ret = g_value_dup_variant (gvalue);
break;
}
break;
case G_VARIANT_CLASS_HANDLE:
case G_VARIANT_CLASS_VARIANT:
case G_VARIANT_CLASS_MAYBE:
case G_VARIANT_CLASS_TUPLE:
case G_VARIANT_CLASS_DICT_ENTRY:
ret = g_value_dup_variant (gvalue);
break;
}
}
/* Could be that the GValue is holding a NULL GVariant - in that case,
* we return an "empty" GVariant instead of a NULL GVariant
*/
if (ret == NULL)
{
GVariant *untrusted_empty;
untrusted_empty = g_variant_new_from_data (type, NULL, 0, FALSE, NULL, NULL);
ret = g_variant_ref_sink (g_variant_get_normal_form (untrusted_empty));
g_variant_unref (untrusted_empty);
}
g_assert (!g_variant_is_floating (ret));
return ret;
}
static gboolean
set_crypto_config (UDisksBlock *block,
const gchar *crypto_passphrase,
const gchar *crypto_options,
GError **error)
{
if (g_strcmp0 (udisks_block_get_id_usage (block), "crypto") != 0)
return TRUE;
GVariantBuilder item;
g_variant_builder_init (&item, G_VARIANT_TYPE("a{sv}"));
const gchar *uuid = udisks_block_get_id_uuid (block);
gs_free gchar *name = NULL;
if (uuid && *uuid)
name = g_strdup_printf ("luks-%s", uuid);
else
{
// just make something up and hope it is unique
name = g_strdup_printf ("luks-%u", g_random_int ());
}
g_variant_builder_add (&item, "{sv}", "name", g_variant_new_bytestring (name));
gs_free gchar *device = NULL;
if (uuid && *uuid)
device = g_strdup_printf ("UUID=%s", uuid);
else
{
// XXX - find a more stable name among the symlinks.
device = udisks_block_dup_device (block);
}
g_variant_builder_add (&item, "{sv}", "device", g_variant_new_bytestring (device));
gs_free gchar *opts = g_locale_from_utf8 (crypto_options, -1, NULL, NULL, error);
if (opts == NULL)
return FALSE;
g_variant_builder_add (&item, "{sv}", "options", g_variant_new_bytestring (opts));
if (crypto_passphrase && *crypto_passphrase)
{
gs_free gchar *path = g_strdup_printf ("/etc/luks-keys/%s", name);
g_variant_builder_add (&item, "{sv}", "passphrase-path",
g_variant_new_bytestring (path));
g_variant_builder_add (&item, "{sv}", "passphrase-contents",
g_variant_new_bytestring (crypto_passphrase));
}
else
{
g_variant_builder_add (&item, "{sv}", "passphrase-path", g_variant_new_bytestring (""));
g_variant_builder_add (&item, "{sv}", "passphrase-contents", g_variant_new_bytestring (""));
}
if (!udisks_block_call_add_configuration_item_sync (block,
g_variant_new ("(sa{sv})",
"crypttab", &item),
g_variant_new ("a{sv}", NULL),
NULL,
error))
return FALSE;
return TRUE;
}
static gboolean
set_fstab_config (UDisksBlock *block,
const gchar *mount_point,
const gchar *mount_options,
GError **error)
{
if (mount_point && *mount_point)
{
gs_unref_object UDisksClient *client = udisks_client_new_sync (NULL, error);
if (client == NULL)
return FALSE;
UDisksBlock *cleartext = udisks_client_get_cleartext_block (client, block);
if (cleartext)
return set_fstab_config (cleartext, mount_point, mount_options, error);
GVariantBuilder item;
g_variant_builder_init (&item, G_VARIANT_TYPE("a{sv}"));
gs_free gchar *fsname = NULL;
const gchar *uuid = udisks_block_get_id_uuid (block);
if (uuid && *uuid)
fsname = g_strdup_printf ("UUID=%s", uuid);
else
{
// XXX - find a more stable name among the symlinks.
fsname = udisks_block_dup_device (block);
}
g_variant_builder_add (&item, "{sv}", "fsname", g_variant_new_bytestring (fsname));
gs_free gchar *dir = g_filename_from_utf8 (mount_point, -1, NULL, NULL, error);
if (dir == NULL)
return FALSE;
g_variant_builder_add (&item, "{sv}", "dir", g_variant_new_bytestring (dir));
if (mount_options && *mount_options)
{
gs_free gchar *opts = g_locale_from_utf8 (mount_options, -1, NULL, NULL, error);
if (opts == NULL)
return FALSE;
g_variant_builder_add (&item, "{sv}", "opts", g_variant_new_bytestring (opts));
}
else
g_variant_builder_add (&item, "{sv}", "opts", g_variant_new_bytestring ("defaults"));
g_variant_builder_add (&item, "{sv}", "type", g_variant_new_bytestring ("auto"));
g_variant_builder_add (&item, "{sv}", "freq", g_variant_new_int32 (0));
g_variant_builder_add (&item, "{sv}", "passno", g_variant_new_int32 (0));
if (!udisks_block_call_add_configuration_item_sync (block,
g_variant_new ("(sa{sv})",
"fstab",
&item),
g_variant_new ("a{sv}", NULL),
NULL,
error))
return FALSE;
}
return TRUE;
}
/**
* Initialize GATT descriptor fields.
*
* This function initializes the @c CAGattDescriptor object fields.
*
* @param[out] c Information about GATT characteristic
* to which the descriptor belongs.
* @param[in] connection D-Bus connection to the bus on which
* the descriptor will be exported.
* @param[in] s Information about GATT service
* information to which the descriptor
* belongs.
* @param[in] descriptor_path @c GattDescriptor1 object path for the
* user description descriptor.
* @param[in] value User description descriptor value,
* e.g. @c "OIC Node Request" or
* @c "OIC Node Response".
*
* @note This function does not allocate the @a descriptor object
* itself. The caller is responsible for allocating that
* memory.
*
* @todo Too many parameters. Perhaps pass in a pointer to a struct
* instead.
*/
static bool CAGattDescriptorInitialize(CAGattCharacteristic * c,
GDBusConnection * connection,
CAGattService * s,
char const * descriptor_path,
char const * value)
{
(void)s;
CAGattDescriptor * const d = &c->descriptor;
// Path of the form /org/iotivity/gatt/hci0/service0/char0/desc0.
d->object_path =
g_strdup_printf("%s/%s", c->object_path, descriptor_path);
assert(g_variant_is_object_path(d->object_path));
d->descriptor = gatt_descriptor1_skeleton_new();
gatt_descriptor1_set_uuid(
d->descriptor,
CA_GATT_CHRC_USER_DESCRIPTION_DESC_UUID);
gatt_descriptor1_set_characteristic(d->descriptor,
c->object_path);
gatt_descriptor1_set_value (d->descriptor,
g_variant_new_bytestring(value));
// Readable, no encryption, no authorization.
static char const * const flags[] = { "read", NULL };
gatt_descriptor1_set_flags(d->descriptor, flags);
/*
Connect the signal handler that implements the
orb.bluez.GattDescriptor1.ReadValue() method.
*/
g_signal_connect(d->descriptor,
"handle-read-value",
G_CALLBACK(CAGattDescriptorReadValue),
NULL);
// Export the descriptor interface on the bus.
GError * error = NULL;
if (!g_dbus_interface_skeleton_export(
G_DBUS_INTERFACE_SKELETON(d->descriptor),
connection,
d->object_path,
&error))
{
CAGattDescriptorDestroy(d);
OIC_LOG_V(ERROR,
TAG,
"Unable to export D-Bus GATT descriptor "
"interface: %s",
error->message);
g_error_free(error);
return false;
}
return true;
}
/**
* Load the session from the specified filename.
*
* @param filename The name of the session file to load. Must not be NULL.
*
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments,
* SR_ERR_MALLOC upon memory allocation errors, or SR_ERR upon
* other errors.
*/
SR_API int sr_session_load(const char *filename)
{
GKeyFile *kf;
GPtrArray *capturefiles;
struct zip *archive;
struct zip_file *zf;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *probe;
int ret, devcnt, i, j, k;
uint16_t probenum;
uint64_t tmp_u64, total_probes, enabled_probes;
uint16_t p;
char **sections, **keys, *metafile, *val, s[11];
char probename[SR_MAX_PROBENAME_LEN + 1];
int mode = LOGIC;
int channel_type = SR_CHANNEL_LOGIC;
double tmp_double;
if (!filename) {
sr_err("%s: filename was NULL", __func__);
return SR_ERR_ARG;
}
if (!(archive = zip_open(filename, 0, &ret))) {
sr_dbg("Failed to open session file: zip error %d", ret);
return SR_ERR;
}
/* read "metadata" */
if (zip_stat(archive, "header", 0, &zs) == -1) {
sr_dbg("Not a valid DSView data file.");
return SR_ERR;
}
if (!(metafile = g_try_malloc(zs.size))) {
sr_err("%s: metafile malloc failed", __func__);
return SR_ERR_MALLOC;
}
zf = zip_fopen_index(archive, zs.index, 0);
zip_fread(zf, metafile, zs.size);
zip_fclose(zf);
kf = g_key_file_new();
if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
sr_dbg("Failed to parse metadata.");
return SR_ERR;
}
sr_session_new();
devcnt = 0;
capturefiles = g_ptr_array_new_with_free_func(g_free);
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i]; i++) {
if (!strcmp(sections[i], "version"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "header", 6)) {
/* device section */
sdi = NULL;
enabled_probes = total_probes = 0;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
if (!strcmp(keys[j], "device mode")) {
mode = strtoull(val, NULL, 10);
} else if (!strcmp(keys[j], "capturefile")) {
sdi = sr_dev_inst_new(mode, devcnt, SR_ST_ACTIVE, NULL, NULL, NULL);
sdi->driver = &session_driver;
if (devcnt == 0)
/* first device, init the driver */
sdi->driver->init(NULL);
sr_dev_open(sdi);
sr_session_dev_add(sdi);
sdi->driver->config_set(SR_CONF_SESSIONFILE,
g_variant_new_bytestring(filename), sdi, NULL, NULL);
sdi->driver->config_set(SR_CONF_CAPTUREFILE,
g_variant_new_bytestring(val), sdi, NULL, NULL);
g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) {
sr_parse_sizestring(val, &tmp_u64);
sdi->driver->config_set(SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "unitsize")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "total samples")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_LIMIT_SAMPLES,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "hDiv")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_TIMEBASE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "total probes")) {
total_probes = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES,
g_variant_new_uint64(total_probes), sdi, NULL, NULL);
channel_type = (mode == DSO) ? SR_CHANNEL_DSO :
(mode == ANALOG) ? SR_CHANNEL_ANALOG : SR_CHANNEL_LOGIC;
for (p = 0; p < total_probes; p++) {
snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
if (!(probe = sr_channel_new(p, channel_type, FALSE,
probename)))
return SR_ERR;
sdi->channels = g_slist_append(sdi->channels, probe);
}
} else if (!strncmp(keys[j], "probe", 5)) {
if (!sdi)
continue;
enabled_probes++;
tmp_u64 = strtoul(keys[j]+5, NULL, 10);
/* sr_session_save() */
sr_dev_probe_name_set(sdi, tmp_u64, val);
sr_dev_probe_enable(sdi, tmp_u64, TRUE);
} else if (!strncmp(keys[j], "trigger", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
sr_dev_trigger_set(sdi, probenum, val);
} else if (!strncmp(keys[j], "enable", 6)) {
probenum = strtoul(keys[j]+6, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_EN_CH,
g_variant_new_boolean(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "coupling", 8)) {
probenum = strtoul(keys[j]+8, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_COUPLING,
g_variant_new_byte(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vDiv", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_VDIV,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vFactor", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_FACTOR,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vPos", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_double = strtod(val, NULL);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_VPOS,
g_variant_new_double(tmp_double), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "period", 6)) {
probenum = strtoul(keys[j]+6, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_PERIOD,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "pcnt", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_PCNT,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "max", 3)) {
probenum = strtoul(keys[j]+3, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_MAX,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "min", 3)) {
probenum = strtoul(keys[j]+3, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_MIN,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
}
}
g_strfreev(keys);
}
devcnt++;
}
g_strfreev(sections);
g_key_file_free(kf);
return SR_OK;
}
gboolean
gtk_file_chooser_native_portal_show (GtkFileChooserNative *self)
{
FilechooserPortalData *data;
GtkWindow *transient_for;
GDBusConnection *connection;
char *parent_window_str;
GDBusMessage *message;
GVariantBuilder opt_builder;
GtkFileChooserAction action;
gboolean multiple;
const char *method_name;
if (!gtk_should_use_portal ())
return FALSE;
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
if (connection == NULL)
return FALSE;
action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (self));
multiple = gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (self));
if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
method_name = "OpenFile";
else if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
method_name = "SaveFile";
else
{
g_warning ("GTK_FILE_CHOOSER_ACTION_%s is not supported by GtkFileChooserNativePortal", action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ? "SELECT_FOLDER" : "CREATE_FOLDER");
return FALSE;
}
data = g_new0 (FilechooserPortalData, 1);
data->self = g_object_ref (self);
data->connection = connection;
message = g_dbus_message_new_method_call ("org.freedesktop.portal.Desktop",
"/org/freedesktop/portal/desktop",
"org.freedesktop.portal.FileChooser",
method_name);
parent_window_str = NULL;
transient_for = gtk_native_dialog_get_transient_for (GTK_NATIVE_DIALOG (self));
if (transient_for != NULL && gtk_widget_is_visible (GTK_WIDGET (transient_for)))
{
GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (transient_for));
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_WINDOW(window))
parent_window_str = g_strdup_printf ("x11:%x", (guint32)gdk_x11_window_get_xid (window));
#endif
}
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
if (data->modal && transient_for != NULL)
{
data->grab_widget = gtk_invisible_new_for_screen (gtk_widget_get_screen (GTK_WIDGET (transient_for)));
gtk_grab_add (GTK_WIDGET (data->grab_widget));
}
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&opt_builder, "{sv}", "multiple",
g_variant_new_boolean (multiple));
if (self->accept_label)
g_variant_builder_add (&opt_builder, "{sv}", "accept_label",
g_variant_new_string (self->accept_label));
if (self->cancel_label)
g_variant_builder_add (&opt_builder, "{sv}", "cancel_label",
g_variant_new_string (self->cancel_label));
g_variant_builder_add (&opt_builder, "{sv}", "modal",
g_variant_new_boolean (data->modal));
g_variant_builder_add (&opt_builder, "{sv}", "filters", get_filters (GTK_FILE_CHOOSER (self)));
if (GTK_FILE_CHOOSER_NATIVE (self)->current_name)
g_variant_builder_add (&opt_builder, "{sv}", "current_name",
g_variant_new_string (GTK_FILE_CHOOSER_NATIVE (self)->current_name));
if (GTK_FILE_CHOOSER_NATIVE (self)->current_folder)
{
gchar *path;
path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_folder);
g_variant_builder_add (&opt_builder, "{sv}", "current_folder",
g_variant_new_bytestring (path));
g_free (path);
}
if (GTK_FILE_CHOOSER_NATIVE (self)->current_file)
{
gchar *path;
path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_file);
g_variant_builder_add (&opt_builder, "{sv}", "current_file",
g_variant_new_bytestring (path));
g_free (path);
}
if (GTK_FILE_CHOOSER_NATIVE (self)->choices)
g_variant_builder_add (&opt_builder, "{sv}", "choices",
serialize_choices (GTK_FILE_CHOOSER_NATIVE (self)));
g_dbus_message_set_body (message,
g_variant_new ("(ss@a{sv})",
parent_window_str ? parent_window_str : "",
gtk_native_dialog_get_title (GTK_NATIVE_DIALOG (self)),
g_variant_builder_end (&opt_builder)));
g_free (parent_window_str);
g_dbus_connection_send_message_with_reply (data->connection,
message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
G_MAXINT,
NULL,
NULL,
open_file_msg_cb,
data);
g_object_unref (message);
self->mode_data = data;
return TRUE;
}
GVariant *
g_settings_set_mapping (const GValue *value,
const GVariantType *expected_type,
gpointer user_data)
{
gchar *type_string;
if (G_VALUE_HOLDS_BOOLEAN (value))
{
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN))
return g_variant_new_boolean (g_value_get_boolean (value));
}
else if (G_VALUE_HOLDS_CHAR (value) ||
G_VALUE_HOLDS_UCHAR (value))
{
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE))
{
if (G_VALUE_HOLDS_CHAR (value))
return g_variant_new_byte (g_value_get_char (value));
else
return g_variant_new_byte (g_value_get_uchar (value));
}
}
else if (G_VALUE_HOLDS_INT (value) ||
G_VALUE_HOLDS_INT64 (value))
return g_settings_set_mapping_int (value, expected_type);
else if (G_VALUE_HOLDS_DOUBLE (value))
return g_settings_set_mapping_float (value, expected_type);
else if (G_VALUE_HOLDS_UINT (value) ||
G_VALUE_HOLDS_UINT64 (value))
return g_settings_set_mapping_unsigned_int (value, expected_type);
else if (G_VALUE_HOLDS_STRING (value))
{
if (g_value_get_string (value) == NULL)
return NULL;
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING))
return g_variant_new_string (g_value_get_string (value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTESTRING))
return g_variant_new_bytestring (g_value_get_string (value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH))
return g_variant_new_object_path (g_value_get_string (value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE))
return g_variant_new_signature (g_value_get_string (value));
}
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
if (g_value_get_boxed (value) == NULL)
return NULL;
return g_variant_new_strv ((const gchar **) g_value_get_boxed (value),
-1);
}
else if (G_VALUE_HOLDS_ENUM (value))
{
GEnumValue *enumval;
GEnumClass *eclass;
/* GParamSpecEnum holds a ref on the class so we just peek... */
eclass = g_type_class_peek (G_VALUE_TYPE (value));
enumval = g_enum_get_value (eclass, g_value_get_enum (value));
if (enumval)
return g_variant_new_string (enumval->value_nick);
else
return NULL;
}
else if (G_VALUE_HOLDS_FLAGS (value))
{
GVariantBuilder builder;
GFlagsValue *flagsval;
GFlagsClass *fclass;
guint flags;
fclass = g_type_class_peek (G_VALUE_TYPE (value));
flags = g_value_get_flags (value);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
while (flags)
{
flagsval = g_flags_get_first_value (fclass, flags);
if (flagsval == NULL)
{
g_variant_builder_clear (&builder);
return NULL;
}
g_variant_builder_add (&builder, "s", flagsval->value_nick);
flags &= ~flagsval->value;
}
return g_variant_builder_end (&builder);
}
type_string = g_variant_type_dup_string (expected_type);
g_critical ("No GSettings bind handler for type \"%s\".", type_string);
g_free (type_string);
return NULL;
}
