static void test_marshal(void) {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL, *n = NULL;
_cleanup_bus_unref_ sd_bus *bus = NULL;
_cleanup_free_ void *blob;
size_t sz;
assert_se(sd_bus_open_system(&bus) >= 0);
bus->message_version = 2; /* dirty hack to enable gvariant*/
assert_se(sd_bus_message_new_method_call(bus, "a.service.name", "/an/object/path/which/is/really/really/long/so/that/we/hit/the/eight/bit/boundary/by/quite/some/margin/to/test/this/stuff/that/it/really/works", "an.interface.name", "AMethodName", &m) >= 0);
assert_se(sd_bus_message_append(m,
"a(usv)", 2,
4711, "first-string-parameter", "(st)", "X", (uint64_t) 1111,
4712, "second-string-parameter", "(a(si))", 2, "Y", 5, "Z", 6) >= 0);
assert_se(bus_message_seal(m, 4711) >= 0);
#ifdef HAVE_GLIB
{
GVariant *v;
char *t;
#if !defined(GLIB_VERSION_2_36)
g_type_init();
#endif
v = g_variant_new_from_data(G_VARIANT_TYPE("(yyyyuuua(yv))"), m->header, sizeof(struct bus_header) + BUS_MESSAGE_FIELDS_SIZE(m), false, NULL, NULL);
t = g_variant_print(v, TRUE);
printf("%s\n", t);
g_free(t);
g_variant_unref(v);
v = g_variant_new_from_data(G_VARIANT_TYPE("(a(usv))"), m->body.data, BUS_MESSAGE_BODY_SIZE(m), false, NULL, NULL);
t = g_variant_print(v, TRUE);
printf("%s\n", t);
g_free(t);
g_variant_unref(v);
}
#endif
assert_se(bus_message_dump(m, NULL, true) >= 0);
assert_se(bus_message_get_blob(m, &blob, &sz) >= 0);
assert_se(bus_message_from_malloc(NULL, blob, sz, NULL, 0, NULL, NULL, &n) >= 0);
blob = NULL;
assert_se(bus_message_dump(n, NULL, true) >= 0);
m = sd_bus_message_unref(m);
assert_se(sd_bus_message_new_method_call(bus, "a.x", "/a/x", "a.x", "Ax", &m) >= 0);
assert_se(sd_bus_message_append(m, "as", 0) >= 0);
assert_se(bus_message_seal(m, 4712) >= 0);
assert_se(bus_message_dump(m, NULL, true) >= 0);
}
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(int key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *gvar;
GVariantBuilder gvb;
(void)sdi;
(void)cg;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
// *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
// hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
*data = g_variant_new_from_data(G_VARIANT_TYPE("ai"),
hwcaps, ARRAY_SIZE(hwcaps)*sizeof(int32_t), TRUE, NULL, NULL);
break;
case SR_CONF_DEVICE_CONFIGS:
// *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
// hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
*data = g_variant_new_from_data(G_VARIANT_TYPE("ai"),
hwoptions, ARRAY_SIZE(hwoptions)*sizeof(int32_t), TRUE, NULL, NULL);
break;
case SR_CONF_DEVICE_SESSIONS:
*data = g_variant_new_from_data(G_VARIANT_TYPE("ai"),
sessions, ARRAY_SIZE(sessions)*sizeof(int32_t), TRUE, NULL, NULL);
break;
case SR_CONF_SAMPLERATE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
// gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
// ARRAY_SIZE(samplerates), sizeof(uint64_t));
gvar = g_variant_new_from_data(G_VARIANT_TYPE("at"),
samplerates, ARRAY_SIZE(samplerates)*sizeof(uint64_t), TRUE, NULL, NULL);
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_LIMIT_SAMPLES:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
gvar = g_variant_new_from_data(G_VARIANT_TYPE("at"),
samplecounts, ARRAY_SIZE(samplecounts)*sizeof(uint64_t), TRUE, NULL, NULL);
g_variant_builder_add(&gvb, "{sv}", "samplecounts", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_PATTERN_MODE:
*data = g_variant_new_strv(pattern_strings, ARRAY_SIZE(pattern_strings));
break;
case SR_CONF_MAX_HEIGHT:
*data = g_variant_new_strv(maxHeights, ARRAY_SIZE(maxHeights));
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
/**
* ot_util_variant_map:
* @src: a #GFile
* @type: Use this for variant
* @trusted: See documentation of g_variant_new_from_data()
* @out_variant: (out): Return location for new variant
* @error:
*
* Memory-map @src, and store a new #GVariant referring to this memory
* in @out_variant. Note the returned @out_variant is not floating.
*/
gboolean
ot_util_variant_map (GFile *src,
const GVariantType *type,
gboolean trusted,
GVariant **out_variant,
GError **error)
{
gboolean ret = FALSE;
gs_unref_variant GVariant *ret_variant = NULL;
GMappedFile *mfile = NULL;
mfile = gs_file_map_noatime (src, NULL, error);
if (!mfile)
goto out;
ret_variant = g_variant_new_from_data (type,
g_mapped_file_get_contents (mfile),
g_mapped_file_get_length (mfile),
trusted,
(GDestroyNotify) g_mapped_file_unref,
mfile);
mfile = NULL;
g_variant_ref_sink (ret_variant);
ret = TRUE;
ot_transfer_out_value(out_variant, &ret_variant);
out:
if (mfile)
g_mapped_file_unref (mfile);
return ret;
}
static void _decode_username_password(GTlmNfc* self, const gchar* data)
{
gsize variant_s_size = 0;
guchar* variant_s = g_base64_decode(data, &variant_s_size);
GVariantType* v_t = g_variant_type_new("(msms)");
GVariant* v = g_variant_new_from_data(v_t, variant_s, variant_s_size, FALSE, NULL, NULL);
if (v == NULL) {
g_debug("Couldn't decode Payload data to variant");
g_variant_type_free(v_t);
g_free(variant_s);
g_signal_emit(self, signals[SIG_NO_RECORD_FOUND], 0);
return;
}
gchar* username = NULL;
gchar* password = NULL;
g_variant_get(v, "(msms)", &username, &password);
g_signal_emit(self, signals[SIG_RECORD_FOUND], 0, username, password);
g_free(username);
g_free(password);
g_variant_unref(v);
g_variant_type_free(v_t);
g_free(variant_s);
}
void get(SoupServer *server,
SoupMessage *msg,
const char *path)
{
struct btval key, val;
key.data = (void*)path+1;
key.size = strlen(path)-1;
key.free_data = FALSE;
key.mp = NULL;
g_debug ("GET\n Path=%s\n Fetching key %s", path, (char*)key.data);
const struct btree_stat *stat = btree_stat(btree);
show_dbstats("",stat);
if (0 == btree_get(btree,&key,&val)) {
g_debug ("hmm %s", (char*)val.data);
GVariant *gv = g_variant_new_from_data(G_VARIANT_TYPE_VARIANT, val.data, val.size, TRUE, NULL, NULL);
char *debug = g_variant_print (gv, TRUE);
g_debug ("converted to %s", debug);
g_free (debug);
g_variant_unref(gv);
soup_message_set_status (msg, SOUP_STATUS_OK);
} else {
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
}
// soup_message_set_response (msg, "application/json", SOUP_MEMORY_STATIC,
// );
}
static void
do_md5sum (SoupMessage *msg, SoupXMLRPCParams *params)
{
GVariant *args;
GVariant *child;
GChecksum *checksum;
GByteArray *digest;
gsize digest_len = 16;
if (!(args = parse_params (msg, params, "(ay)")))
return;
child = g_variant_get_child_value (args, 0);
checksum = g_checksum_new (G_CHECKSUM_MD5);
g_checksum_update (checksum,
g_variant_get_data (child),
g_variant_get_size (child));
digest = g_byte_array_new ();
g_byte_array_set_size (digest, digest_len);
g_checksum_get_digest (checksum, digest->data, &digest_len);
g_checksum_free (checksum);
soup_xmlrpc_message_set_response (msg,
g_variant_new_from_data (G_VARIANT_TYPE_BYTESTRING,
digest->data, digest_len,
TRUE, NULL, NULL),
NULL);
g_byte_array_free (digest, TRUE);
g_variant_unref (child);
g_variant_unref (args);
}
/**
* Read all input from @src, allocating a new #GVariant from it into
* output variable @out_variant. @src will be closed as a result.
*
* Note the returned @out_variant is not floating.
*/
gboolean
ot_util_variant_from_stream (GInputStream *src,
const GVariantType *type,
gboolean trusted,
GVariant **out_variant,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
gs_unref_object GMemoryOutputStream *data_stream = NULL;
gs_unref_variant GVariant *ret_variant = NULL;
data_stream = (GMemoryOutputStream*)g_memory_output_stream_new (NULL, 0, g_realloc, g_free);
if (g_output_stream_splice ((GOutputStream*)data_stream, src,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
cancellable, error) < 0)
goto out;
ret_variant = g_variant_new_from_data (type, g_memory_output_stream_get_data (data_stream),
g_memory_output_stream_get_data_size (data_stream),
trusted, (GDestroyNotify) g_object_unref, data_stream);
data_stream = NULL; /* Transfer ownership */
g_variant_ref_sink (ret_variant);
ret = TRUE;
ot_transfer_out_value (out_variant, &ret_variant);
out:
return ret;
}
static void
test_g_variant_dict (void)
{
g_autoptr(GVariant) data = g_variant_new_from_data (G_VARIANT_TYPE ("a{sv}"), "", 0, FALSE, NULL, NULL);
g_auto(GVariantDict) stackval;
g_autoptr(GVariantDict) val = g_variant_dict_new (data);
g_variant_dict_init (&stackval, data);
g_assert (val != NULL);
}
static GVariant *
new_bytearray (const guchar *data,
gsize len)
{
gpointer data_copy = g_memdup (data, len);
GVariant *ret = g_variant_new_from_data (G_VARIANT_TYPE ("ay"), data_copy,
len, FALSE, g_free, data_copy);
return ret;
}
GVariant *
ot_gvariant_new_ay_bytes (GBytes *bytes)
{
gsize size;
gconstpointer data;
data = g_bytes_get_data (bytes, &size);
g_bytes_ref (bytes);
return g_variant_new_from_data (G_VARIANT_TYPE ("ay"), data, size,
TRUE, (GDestroyNotify)g_bytes_unref, bytes);
}
static GVariant *
string_to_ay (const char *string)
{
gsize len;
char *data;
len = strlen (string);
data = g_strndup (string, len);
return g_variant_new_from_data (G_VARIANT_TYPE ("ay"), data, len, TRUE, g_free, data);
}
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;
}
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;
}
GVariant *
vino_set_password (const GValue *value,
const GVariantType *type,
gpointer user_data)
{
const gchar *string;
gchar *base64;
string = g_value_get_string (value);
base64 = g_base64_encode ((guchar *) string, strlen (string));
return g_variant_new_from_data (G_VARIANT_TYPE_STRING,
base64, strlen (base64) + 1,
TRUE, g_free, base64);
}
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
{
GVariant *gvar;
GVariantBuilder gvb;
(void)sdi;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
// *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
// hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
*data = g_variant_new_from_data(G_VARIANT_TYPE("ai"),
hwcaps, ARRAY_SIZE(hwcaps)*sizeof(int32_t), TRUE, NULL, NULL);
break;
case SR_CONF_SAMPLERATE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
// gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
// ARRAY_SIZE(samplerates), sizeof(uint64_t));
gvar = g_variant_new_from_data(G_VARIANT_TYPE("at"),
samplerates, ARRAY_SIZE(samplerates)*sizeof(uint64_t), TRUE, NULL, NULL);
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_LIMIT_SAMPLES:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
gvar = g_variant_new_from_data(G_VARIANT_TYPE("at"),
samplecounts, ARRAY_SIZE(samplecounts)*sizeof(uint64_t), TRUE, NULL, NULL);
g_variant_builder_add(&gvb, "{sv}", "samplecounts", gvar);
*data = g_variant_builder_end(&gvb);
break;
default:
return SR_ERR_ARG;
}
return SR_OK;
}
GVariant *
ot_variant_new_from_bytes (const GVariantType *type,
GBytes *bytes,
gboolean trusted)
{
#if GLIB_VERSION_MIN_REQUIRED >= GLIB_VERSION_2_36
return g_variant_new_from_bytes (type, bytes, trusted);
#else
gsize size;
gconstpointer data = g_bytes_get_data (bytes, &size);
g_bytes_ref (bytes);
return g_variant_new_from_data (type, data, size, trusted,
(GDestroyNotify)g_bytes_unref, bytes);
#endif
}
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 int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
{
(void)sdi;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
// *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
// hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
*data = g_variant_new_from_data(G_VARIANT_TYPE("ai"),
hwcaps, ARRAY_SIZE(hwcaps)*sizeof(int32_t), TRUE, NULL, NULL);
break;
default:
return SR_ERR_ARG;
}
return SR_OK;
}
void
storage_provider_load_remembered_configs (StorageProvider *provider)
{
gchar *info_data;
gsize info_size;
GError *error = NULL;
g_mutex_lock (&provider->remembered_configs_mutex);
if (!g_file_get_contents (PACKAGE_LOCALSTATE_DIR "/lib/cockpit/hidden-configs",
&info_data, &info_size,
&error))
{
if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
g_warning ("Can't load hidden configs: %s", error->message);
g_clear_error (&error);
g_mutex_unlock (&provider->remembered_configs_mutex);
return;
}
gs_unref_variant GVariant *info = g_variant_new_from_data (G_VARIANT_TYPE ("a{sa{sv}}"),
info_data, info_size, TRUE,
g_free, NULL);
GVariantIter parent_iter, *child_iter;
const gchar *parent_path, *child_path;
GVariant *config;
g_hash_table_remove_all (provider->remembered_configs);
g_variant_iter_init (&parent_iter, info);
while (g_variant_iter_next (&parent_iter, "{&sa{sv}}", &parent_path, &child_iter))
{
while (g_variant_iter_next (child_iter, "{&sv}", &child_path, &config))
{
remember_config_inlock (provider, parent_path, child_path, config);
g_variant_unref (config);
}
g_variant_iter_free (child_iter);
}
provider->remembered_configs_need_save = FALSE;
g_mutex_unlock (&provider->remembered_configs_mutex);
}
void get(SoupServer *server,
SoupMessage *msg,
const char *path)
{
struct btval key, val;
key.data = (void*)path+1;
key.size = strlen(path)-1;
key.free_data = FALSE;
key.mp = NULL;
g_debug ("GET\n Path=%s\n Fetching key %s", path, (char*)key.data);
const struct btree_stat *stat = btree_stat(btree);
show_dbstats("",stat);
if (0 == btree_get(btree,&key,&val)) {
g_debug ("data checksum is %s", g_compute_checksum_for_data(G_CHECKSUM_MD5, val.data, val.size));
/* we need to make the data 64 bits aligned for gvariant.
Best plan is to make all data aligned in the store, but
for now, lets just copy it to somewhere aligned.
TODO: think about fragmentation. it may just be ok, as so far
we delete everything we malloc in this function, despite the
lifetimes being interleaved.
*/
char *buf = g_slice_alloc(val.size + 8);
char *data = ALIGN_64(buf);
memcpy (data, val.data, val.size);
g_debug ("aligned data checksum is %s", g_compute_checksum_for_data(G_CHECKSUM_MD5, data, val.size));
GVariant *gv = g_variant_new_from_data(G_VARIANT_TYPE_VARIANT, data, val.size, TRUE, NULL, NULL);
char *debug = g_variant_print (gv, TRUE);
g_debug ("converted to %s", debug);
g_free (debug);
int length;
char* ret = json_gvariant_serialize_data(gv, &length);
g_variant_unref(gv);
g_slice_free1 (val.size + 8, buf);
soup_message_set_status (msg, SOUP_STATUS_OK);
/*TODO: does soup do anything sensible with it's memory management of responses to reduce the risk of fragmentation? probably not..*/
soup_message_set_response (msg, "application/json", SOUP_MEMORY_TAKE, ret, length);
} else {
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
}
}
static GVariant *
request_open_session_aes (SecretSession *session)
{
gcry_error_t gcry;
gcry_mpi_t base;
unsigned char *buffer;
size_t n_buffer;
GVariant *argument;
g_assert (session->prime == NULL);
g_assert (session->privat == NULL);
g_assert (session->publi == NULL);
egg_libgcrypt_initialize ();
/* Initialize our local parameters and values */
if (!egg_dh_default_params ("ietf-ike-grp-modp-1024",
&session->prime, &base))
g_return_val_if_reached (NULL);
#if 0
g_printerr ("\n lib prime: ");
gcry_mpi_dump (session->prime);
g_printerr ("\n lib base: ");
gcry_mpi_dump (base);
g_printerr ("\n");
#endif
if (!egg_dh_gen_pair (session->prime, base, 0,
&session->publi, &session->privat))
g_return_val_if_reached (NULL);
gcry_mpi_release (base);
gcry = gcry_mpi_aprint (GCRYMPI_FMT_USG, &buffer, &n_buffer, session->publi);
g_return_val_if_fail (gcry == 0, NULL);
argument = g_variant_new_from_data (G_VARIANT_TYPE ("ay"),
buffer, n_buffer, TRUE,
gcry_free, buffer);
return g_variant_new ("(sv)", ALGORITHMS_AES, argument);
}
/**
* gd_create_variant_from_pixbuf:
* @pixbuf:
*
* Returns: (transfer full):
*/
GVariant *
gd_create_variant_from_pixbuf (GdkPixbuf *pixbuf)
{
GVariant *variant;
guchar *data;
guint length;
data = gdk_pixbuf_get_pixels_with_length (pixbuf, &length);
variant = g_variant_new ("(iiibii@ay)",
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf),
gdk_pixbuf_get_bits_per_sample (pixbuf),
gdk_pixbuf_get_n_channels (pixbuf),
g_variant_new_from_data (G_VARIANT_TYPE_BYTESTRING,
data, length, TRUE,
(GDestroyNotify)g_object_unref,
g_object_ref (pixbuf)));
return g_variant_ref_sink (variant);
}
/**
* Return in @out_variant the result of memory-mapping the entire
* contents of file @src.
*
* Note the returned @out_variant is not floating.
*/
gboolean
ot_util_variant_map (GFile *src,
const GVariantType *type,
gboolean trusted,
GVariant **out_variant,
GError **error)
{
gboolean ret = FALSE;
const char *path = NULL;
ot_lvariant GVariant *ret_variant = NULL;
GMappedFile *mfile = NULL;
int fd;
path = ot_gfile_get_path_cached (src);
if (!ot_unix_open_noatime (path, &fd, error))
goto out;
mfile = g_mapped_file_new_from_fd (fd, FALSE, error);
if (!mfile)
goto out;
if (!ot_unix_close (fd, error))
goto out;
ret_variant = g_variant_new_from_data (type,
g_mapped_file_get_contents (mfile),
g_mapped_file_get_length (mfile),
trusted,
(GDestroyNotify) g_mapped_file_unref,
mfile);
mfile = NULL;
g_variant_ref_sink (ret_variant);
ret = TRUE;
ot_transfer_out_value(out_variant, &ret_variant);
out:
if (mfile)
g_mapped_file_unref (mfile);
return ret;
}
static void
variant_reader_watch_child (GPid pid,
gint status,
gpointer user_data)
{
struct VariantReaderData *data = user_data;
guint8 *buf;
gsize buf_size;
GVariant *result;
GError *error = NULL;
data->pid = 0;
if (!g_spawn_check_exit_status (status, &error))
{
data->callback (pid, NULL, error, data->user_data);
g_error_free (error);
g_byte_array_free (data->output, TRUE);
}
else
{
if (g_io_channel_read_to_end (data->output_channel, (gchar **)&buf, &buf_size, NULL) == G_IO_STATUS_NORMAL)
{
g_byte_array_append (data->output, buf, buf_size);
g_free (buf);
}
result = g_variant_new_from_data (data->type,
data->output->data,
data->output->len,
TRUE,
g_free, NULL);
g_byte_array_free (data->output, FALSE);
data->callback (pid, result, NULL, data->user_data);
g_variant_unref (result);
}
}
gboolean
ot_util_variant_map_fd (GFileDescriptorBased *stream,
goffset start,
const GVariantType *type,
gboolean trusted,
GVariant **out_variant,
GError **error)
{
gboolean ret = FALSE;
gpointer map;
struct stat stbuf;
VariantMapData *mdata = NULL;
gsize len;
if (!gs_stream_fstat (stream, &stbuf, NULL, error))
goto out;
len = stbuf.st_size - start;
map = mmap (NULL, len, PROT_READ, MAP_PRIVATE,
g_file_descriptor_based_get_fd (stream), start);
if (!map)
{
ot_util_set_error_from_errno (error, errno);
goto out;
}
mdata = g_new (VariantMapData, 1);
mdata->addr = map;
mdata->len = len;
ret = TRUE;
*out_variant = g_variant_new_from_data (type, map, len, trusted,
variant_map_data_destroy, mdata);
out:
return ret;
}
static void test_marshal(void) {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL, *n = NULL;
_cleanup_bus_flush_close_unref_ sd_bus *bus = NULL;
_cleanup_free_ void *blob;
size_t sz;
int r;
r = sd_bus_open_system(&bus);
if (r < 0)
exit(EXIT_TEST_SKIP);
bus->message_version = 2; /* dirty hack to enable gvariant */
assert_se(sd_bus_message_new_method_call(bus, &m, "a.service.name", "/an/object/path/which/is/really/really/long/so/that/we/hit/the/eight/bit/boundary/by/quite/some/margin/to/test/this/stuff/that/it/really/works", "an.interface.name", "AMethodName") >= 0);
assert_cc(sizeof(struct bus_header) == 16);
assert_se(sd_bus_message_append(m,
"a(usv)", 3,
4711, "first-string-parameter", "(st)", "X", (uint64_t) 1111,
4712, "second-string-parameter", "(a(si))", 2, "Y", 5, "Z", 6,
4713, "third-string-parameter", "(uu)", 1, 2) >= 0);
assert_se(bus_message_seal(m, 4711, 0) >= 0);
#ifdef HAVE_GLIB
{
GVariant *v;
char *t;
#if !defined(GLIB_VERSION_2_36)
g_type_init();
#endif
v = g_variant_new_from_data(G_VARIANT_TYPE("(yyyyuta{tv})"), m->header, sizeof(struct bus_header) + m->fields_size, false, NULL, NULL);
assert_se(g_variant_is_normal_form(v));
t = g_variant_print(v, TRUE);
printf("%s\n", t);
g_free(t);
g_variant_unref(v);
v = g_variant_new_from_data(G_VARIANT_TYPE("(a(usv))"), m->body.data, m->user_body_size, false, NULL, NULL);
assert_se(g_variant_is_normal_form(v));
t = g_variant_print(v, TRUE);
printf("%s\n", t);
g_free(t);
g_variant_unref(v);
}
#endif
assert_se(bus_message_dump(m, NULL, BUS_MESSAGE_DUMP_WITH_HEADER) >= 0);
assert_se(bus_message_get_blob(m, &blob, &sz) >= 0);
#ifdef HAVE_GLIB
{
GVariant *v;
char *t;
v = g_variant_new_from_data(G_VARIANT_TYPE("(yyyyuta{tv}v)"), blob, sz, false, NULL, NULL);
assert_se(g_variant_is_normal_form(v));
t = g_variant_print(v, TRUE);
printf("%s\n", t);
g_free(t);
g_variant_unref(v);
}
#endif
assert_se(bus_message_from_malloc(bus, blob, sz, NULL, 0, NULL, &n) >= 0);
blob = NULL;
assert_se(bus_message_dump(n, NULL, BUS_MESSAGE_DUMP_WITH_HEADER) >= 0);
m = sd_bus_message_unref(m);
assert_se(sd_bus_message_new_method_call(bus, &m, "a.x", "/a/x", "a.x", "Ax") >= 0);
assert_se(sd_bus_message_append(m, "as", 0) >= 0);
assert_se(bus_message_seal(m, 4712, 0) >= 0);
assert_se(bus_message_dump(m, NULL, BUS_MESSAGE_DUMP_WITH_HEADER) >= 0);
}
// Store (key,value) pairs from a GHashTable in the kwallet.
// Every 'slot' has to take care of it's own data.
gboolean dt_pwstorage_kwallet_set(const backend_kwallet_context_t *context, const gchar* slot, GHashTable* table)
{
printf("slot %s\n", slot);
GArray* byte_array = g_array_new(FALSE, FALSE, sizeof(gchar));
GHashTableIter iter;
g_hash_table_iter_init (&iter, table);
gpointer key, value;
guint size = g_hash_table_size(table);
size = GINT_TO_BE(size);
g_array_append_vals(byte_array, &size, sizeof(guint)/sizeof(gchar));
while (g_hash_table_iter_next (&iter, &key, &value))
{
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_kwallet_set] storing (%s, %s)\n",(gchar*)key, (gchar*)value);
gsize length;
gchar* new_key = char2qstring(key, &length);
if(new_key == NULL)
{
g_free(g_array_free(byte_array, FALSE));
return FALSE;
}
g_array_append_vals(byte_array, new_key, length);
g_free(new_key);
gchar* new_value = char2qstring(value, &length);
if(new_value == NULL)
{
g_free(g_array_free(byte_array, FALSE));
return FALSE;
}
g_array_append_vals(byte_array, new_value, length);
g_free(new_value);
}
int wallet_handle = get_wallet_handle(context);
GError* error = NULL;
/* signature:
*
* in i handle,
* in s folder,
* in s key,
* in ay value,
* in s appid,
*
* out i arg_0
*/
GVariant *ret = g_dbus_proxy_call_sync(context->proxy,
"writeMap",
g_variant_new("(iss@ays)", wallet_handle, kwallet_folder, slot,
g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING,
byte_array->data,
byte_array->len,
TRUE,
g_free,
byte_array->data),
app_id),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
g_array_free(byte_array, FALSE);
if(check_error(error))
{
g_variant_unref(ret);
return FALSE;
}
GVariant *child = g_variant_get_child_value(ret, 0);
int return_code = g_variant_get_int32(child);
g_variant_unref(child);
g_variant_unref(ret);
if (return_code != 0)
dt_print(DT_DEBUG_PWSTORAGE,"[pwstorage_kwallet_set] Warning: bad return code %d from kwallet\n", return_code);
return return_code == 0;
}
static void
name_lost_cb (GDBusConnection *connection,
const char *name,
gpointer user_data)
{
OwnData *data = (OwnData *) user_data;
GError *error = NULL;
char **envv;
int i;
GVariantBuilder builder;
GVariant *value;
GString *string;
char *s;
gsize len;
_terminal_debug_print (TERMINAL_DEBUG_FACTORY,
"Lost the name %s on the session bus\n", name);
/* Couldn't get the connection? No way to continue! */
if (connection == NULL)
{
data->exit_code = EXIT_FAILURE;
gtk_main_quit ();
return;
}
if (data->options == NULL)
{
/* Already handled */
data->exit_code = EXIT_SUCCESS;
gtk_main_quit ();
return;
}
_terminal_debug_print (TERMINAL_DEBUG_FACTORY,
"Forwarding arguments to existing instance\n");
g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ayayayayiay)"));
g_variant_builder_add (&builder, "@ay", string_to_ay (data->options->default_working_dir));
g_variant_builder_add (&builder, "@ay", string_to_ay (data->options->display_name));
g_variant_builder_add (&builder, "@ay", string_to_ay (data->options->startup_id));
string = g_string_new (NULL);
envv = g_get_environ ();
for (i = 0; envv[i]; ++i)
{
if (i > 0)
g_string_append_c (string, '\0');
g_string_append (string, envv[i]);
}
g_strfreev (envv);
len = string->len;
s = g_string_free (string, FALSE);
g_variant_builder_add (&builder, "@ay",
g_variant_new_from_data (G_VARIANT_TYPE ("ay"), s, len, TRUE, g_free, s));
g_variant_builder_add (&builder, "@i", g_variant_new_int32 (data->options->initial_workspace));
string = g_string_new (NULL);
for (i = 0; i < data->argc; ++i)
{
if (i > 0)
g_string_append_c (string, '\0');
g_string_append (string, data->argv[i]);
}
len = string->len;
s = g_string_free (string, FALSE);
g_variant_builder_add (&builder, "@ay",
g_variant_new_from_data (G_VARIANT_TYPE ("ay"), s, len, TRUE, g_free, s));
value = g_dbus_connection_call_sync (connection,
data->factory_name,
TERMINAL_FACTORY_SERVICE_PATH,
TERMINAL_FACTORY_INTERFACE_NAME,
"HandleArguments",
g_variant_builder_end (&builder),
G_VARIANT_TYPE ("()"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (value == NULL)
{
g_printerr ("Failed to forward arguments: %s\n", error->message);
g_error_free (error);
data->exit_code = EXIT_FAILURE;
gtk_main_quit ();
}
else
{
g_variant_unref (value);
data->exit_code = EXIT_SUCCESS;
}
terminal_options_free (data->options);
data->options = NULL;
gtk_main_quit ();
}
EVENTD_EXPORT
FilenameProcessResult
evhelpers_filename_process(const Filename *filename, EventdEvent *event, const gchar *subdir, gchar **ret_uri, GVariant **ret_data)
{
g_return_val_if_fail(filename != NULL, FILENAME_PROCESS_RESULT_NONE);
g_return_val_if_fail(event != NULL, FILENAME_PROCESS_RESULT_NONE);
g_return_val_if_fail(subdir != NULL, FILENAME_PROCESS_RESULT_NONE);
g_return_val_if_fail(ret_uri != NULL, FILENAME_PROCESS_RESULT_NONE);
g_return_val_if_fail(ret_data != NULL, FILENAME_PROCESS_RESULT_NONE);
gchar *uri = NULL;
if ( filename->data_name != NULL )
{
GVariant *data;
data = eventd_event_get_data(event, filename->data_name);
if ( data == NULL )
return FILENAME_PROCESS_RESULT_NONE;
if ( g_variant_is_of_type(data, G_VARIANT_TYPE_STRING) )
uri = g_variant_dup_string(data, NULL);
else if ( g_variant_is_of_type(data, G_VARIANT_TYPE("(msmsv)")) )
{
*ret_data = g_variant_ref(data);
return FILENAME_PROCESS_RESULT_DATA;
}
else
return FILENAME_PROCESS_RESULT_NONE;
}
else if ( filename->file_uri != NULL )
uri = evhelpers_format_string_get_string(filename->file_uri, event, NULL, NULL);
else
g_return_val_if_reached(FILENAME_PROCESS_RESULT_NONE);
if ( uri == NULL )
return FILENAME_PROCESS_RESULT_NONE;
if ( *uri == '\0' )
{
g_free(uri);
return FILENAME_PROCESS_RESULT_NONE;
}
if ( g_str_has_prefix(uri, "data:") )
{
gchar *mime_type = uri + strlen("data:");
if ( _evhelpers_filename_check_data_base64_prefix(mime_type) )
{
gchar *c;
guchar *data;
gsize length;
/* We checked for ";base64," already */
c = g_utf8_strchr(mime_type, -1, ',');
*c = '\0';
data = g_base64_decode(c + 1, &length);
c = g_utf8_strchr(mime_type, c - mime_type, ';');
*c++ = '\0';
if ( *mime_type == '\0' )
mime_type = NULL;
if ( *c == '\0' )
c = NULL;
*ret_data = g_variant_new("(msmsv)", mime_type, c, g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING, data, length, FALSE, g_free, data));
g_free(uri);
return FILENAME_PROCESS_RESULT_DATA;
}
}
else if ( g_str_has_prefix(uri, "file://") )
{
const gchar *p = uri + strlen("file://");
if ( ! g_path_is_absolute(p) )
{
gchar *tmp = uri;
if ( g_path_is_absolute(subdir) )
uri = g_strconcat("file://", subdir, G_DIR_SEPARATOR_S, p, NULL);
else
uri = g_strconcat("file://", g_get_user_data_dir(), G_DIR_SEPARATOR_S PACKAGE_NAME G_DIR_SEPARATOR_S, subdir, G_DIR_SEPARATOR_S, p, NULL);
g_free(tmp);
p = uri + strlen("file://");
}
if ( g_file_test(p, G_FILE_TEST_IS_REGULAR) )
{
*ret_uri = uri;
return FILENAME_PROCESS_RESULT_URI;
}
}
else if ( g_str_has_prefix(uri, "theme:") )
{
*ret_uri = uri;
return FILENAME_PROCESS_RESULT_THEME;
}
g_free(uri);
return FILENAME_PROCESS_RESULT_NONE;
}
