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