Now it's possible to use GLib API for owning bus names, like:
g_bus_own_name() or g_bus_own_name_on_connection(). It is not yet
fully functional until I'll add 'Add Match' method on kdbus, so
g_bus_unown_name() still doesn't invoke proper handler, when 'name'
is lost - work in progress.
For kdbus purpose we need introduce two new bus types
called "user" and "machine". Will not be possible to
make calls to the 'org.freedesktop.DBus' destination on
the new bus types, thus this patch introduce new API
for tasks such as "get Unix user ID of the process connected
to the server", "returns a list of all currently-owned names
on the bus" and so on.
Change-Id: Ib9ba65346290d597341d4157b09cb45bd3d1151d
Take GVariantTypeInfo instead of a GVariantType on the internal
constructors for GVariant.
Although this results in a bit more code for almost every call, it turns
out that it makes most uses more convenient -- that fact that we consume
the GVariantInfo means that we don't have to go back to free the type
when we're done.
This change will allow us to port g_variant_get_child() over to using
g_variant_alloc(). It was the one outstanding place where we
constructed GVariant instances that was not yet using it.
Add a new pair of internal helpers to gvariant-core.c to provide a
unified way to construct and query the content of serialised GVariant
instances.
Rewrite g_variant_new_from_data() to use this.
Move g_variant_new_from_bytes() and g_variant_get_data_as_bytes() out of
-core and into gvariant.c, also rewriting them to use the same.
Take the time to do some cleanup and make some general improvements in
consistency:
- move the checks for improperly sized fixed-sized data out of
_new_from_bytes() and into the common code so that we do this check
on _new_from_data() as well
- correctly deal with the case of NULL data in _get_data_as_bytes().
This would have crashed before. Add a test for that.
- if the user hands us data with a size of zero then unref and/or
destroy-notify things immediately.
The idea that every GVariant must have an associated GBytes remains.
This could potentially be optimsed a bit further in the future, but the
cases where it could be avoided are only a few (errors, zero-size,
static stoarge) so let's not pursue that now.
Add a new type 'f' to correspond to single precision floating point
values.
This type was never added to D-Bus for two reasons:
1) there is no benefit to using float rather than doubles as parameters
for RPC
2) classically, you shouldn't move bulk data over D-Bus
Now that we've decided that we want to use D-Bus for bulk data
transfers, it makes a good deal of sense to want to send an array of
floats or an array of fixed-sized tuples containing floats.
https://bugzilla.gnome.org/show_bug.cgi?id=740897
This structure (and its associated functions) will be used as an
intermediate step for serialising GVariant instance onto kdbus without
copying large amounts of data.
Change the internal g_variant_ensure_serialised() helper over to working
on unlocked instances and have it conditionally acquire the lock using
the utility function added in the last commit.
Many of the core GVariant operations have two modes: one for tree-form
and one for serialised.
Once a GVariant is in serialised form it will always be serialised, so
it is safe to simply check for that and proceed with the operation in
that case.
A tree-form GVariant instance always has a chance of being implicitly
serialised, however, so we have to take locks when performing operations
on these.
Write a helper function that reliably checks if the instance is in
tree-form, locking it if it is. Rewrite some of the other functions to
use this helper. In some cases this simplifies the code and in others
it reduces locking.
It's always possible to determine the serialised size of a GVariant
instance, even in the case that it is not yet serialised. This can be
done by calling g_variant_get_size() which will base its answer on the
size of each child (which must be recursively determined).
We must perform this process before we can allocate the buffer to
serialise a GVariant into (since we must know the size of the buffer).
This means that serialising a GVariant involves two steps that recurse
through the entire tree of values. We must take locks twice.
Simplify this by always determining the size when the instance is first
created, from the sizes of its children (which now will always be known
as well). We can do this without taking any locks because the
newly-created instance has never been exposed and because the size on
the children is now a constant that can be directly accessed without a
lock.
This is a reduction in complexity and will also be a performance
improvement in all cases where a GVariant is serialised. It will be a
slight performance hit in the case that we construct tree-form instances
and never serialise them.
Add a function that checks if a fd is sealed and, if it's not, seals it.
On Linux this is more or less an operation on memfd. On other systems,
it currently always returns FALSE.
We have a wide variety of different sources of data for GBytes.
Instead of having all possibilities inside of a single structure type,
add a 'type' field and a couple of subtypes.
This also forces us to clean up our access to the ->data pointer from
all over the code which may become a problem in the future if we want to
lazy-map memfd GBytes instances by keeping the data pointer as NULL
until we are ready to use it.
We also introduce a new type of GBytes: 'inline'. This allows us to
make a single allocation instead of two in the g_bytes_new() case.
Add g_assert_se(), g_return_if_fail_se() and g_return_val_if_fail_se()
as variants of the existing macros that are guaranteed to evaluate side
effects in their expression argument. Inspired by similar macros in
systemd.
These are just macros, so they come at no extra cost.
https://bugzilla.gnome.org/show_bug.cgi?id=741026
