2 * Copyright © 2007, 2008 Ryan Lortie
3 * Copyright © 2010 Codethink Limited
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
21 #include <glib/gvariant-core.h>
23 #include <glib/gvariant-serialiser.h>
24 #include <glib/gtestutils.h>
25 #include <glib/gbitlock.h>
26 #include <glib/gatomic.h>
27 #include <glib/gbufferprivate.h>
28 #include <glib/gslice.h>
29 #include <glib/gmem.h>
34 * This file includes the structure definition for GVariant and a small
35 * set of functions that are allowed to access the structure directly.
37 * This minimises the amount of code that can possibly touch a GVariant
38 * structure directly to a few simple fundamental operations. These few
39 * operations are written to be completely threadsafe with respect to
40 * all possible outside access. This means that we only need to be
41 * concerned about thread safety issues in this one small file.
43 * Most GVariant API functions are in gvariant.c.
49 * #GVariant is an opaque data structure and can only be accessed
50 * using the following functions.
55 /* see below for field member documentation */
57 GVariantTypeInfo
*type_info
;
81 * There are two primary forms of GVariant instances: "serialised form"
84 * "serialised form": A serialised GVariant instance stores its value in
85 * the GVariant serialisation format. All
86 * basic-typed instances (ie: non-containers) are in
87 * serialised format, as are some containers.
89 * "tree form": Some containers are in "tree form". In this case,
90 * instead of containing the serialised data for the
91 * container, the instance contains an array of pointers to
92 * the child values of the container (thus forming a tree).
94 * It is possible for an instance to transition from tree form to
95 * serialised form. This happens, implicitly, if the serialised data is
96 * requested (eg: via g_variant_get_data()). Serialised form instances
97 * never transition into tree form.
100 * The fields of the structure are documented here:
102 * type_info: this is a reference to a GVariantTypeInfo describing the
103 * type of the instance. When the instance is freed, this
104 * reference must be released with g_variant_type_info_unref().
106 * The type_info field never changes during the life of the
107 * instance, so it can be accessed without a lock.
109 * size: this is the size of the serialised form for the instance, if it
110 * is known. If the instance is in serialised form then it is, by
111 * definition, known. If the instance is in tree form then it may
112 * be unknown (in which case it is -1). It is possible for the
113 * size to be known when in tree form if, for example, the user
114 * has called g_variant_get_size() without calling
115 * g_variant_get_data(). Additionally, even when the user calls
116 * g_variant_get_data() the size of the data must first be
117 * determined so that a large enough buffer can be allocated for
120 * Once the size is known, it can never become unknown again.
121 * g_variant_ensure_size() is used to ensure that the size is in
122 * the known state -- it calculates the size if needed. After
123 * that, the size field can be accessed without a lock.
125 * contents: a union containing either the information associated with
126 * holding a value in serialised form or holding a value in
129 * .serialised: Only valid when the instance is in serialised form.
131 * Since an instance can never transition away from
132 * serialised form, once these fields are set, they will
133 * never be changed. It is therefore valid to access
134 * them without holding a lock.
136 * .buffer: the #GBuffer that contains the memory pointed to by
137 * .data, or %NULL if .data is %NULL. In the event that
138 * the instance was deserialised from another instance,
139 * then the buffer will be shared by both of them. When
140 * the instance is freed, this reference must be released
141 * with g_buffer_unref().
143 * .data: the serialised data (of size 'size') of the instance.
144 * This pointer should not be freed or modified in any way.
145 * #GBuffer is responsible for memory management.
147 * This pointer may be %NULL in two cases:
149 * - if the serialised size of the instance is 0
151 * - if the instance is of a fixed-sized type and was
152 * deserialised out of a corrupted container such that
153 * the container contains too few bytes to point to the
154 * entire proper fixed-size of this instance. In this
155 * case, 'size' will still be equal to the proper fixed
156 * size, but this pointer will be %NULL. This is exactly
157 * the reason that g_variant_get_data() sometimes returns
158 * %NULL. For all other calls, the effect should be as
159 * if .data pointed to the appropriate number of nul
162 * .tree: Only valid when the instance is in tree form.
164 * Note that accesses from other threads could result in
165 * conversion of the instance from tree form to serialised form
166 * at any time. For this reason, the instance lock must always
167 * be held while performing any operations on 'contents.tree'.
169 * .children: the array of the child instances of this instance.
170 * When the instance is freed (or converted to serialised
171 * form) then each child must have g_variant_unref()
172 * called on it and the array must be freed using
175 * .n_children: the number of items in the .children array.
177 * state: a bitfield describing the state of the instance. It is a
178 * bitwise-or of the following STATE_* constants:
180 * STATE_LOCKED: the instance lock is held. This is the bit used by
183 * STATE_SERIALISED: the instance is in serialised form. If this
184 * flag is not set then the instance is in tree
187 * STATE_TRUSTED: for serialised form instances, this means that the
188 * serialised data is known to be in normal form (ie:
191 * For tree form instances, this means that all of the
192 * child instances in the contents.tree.children array
193 * are trusted. This means that if the container is
194 * serialised then the resulting data will be in
197 * If this flag is unset it does not imply that the
198 * data is corrupted. It merely means that we're not
199 * sure that it's valid. See g_variant_is_trusted().
201 * STATE_FLOATING: if this flag is set then the object has a floating
202 * reference. See g_variant_ref_sink().
204 * ref_count: the reference count of the instance
206 #define STATE_LOCKED 1
207 #define STATE_SERIALISED 2
208 #define STATE_TRUSTED 4
209 #define STATE_FLOATING 8
214 * @value: a #GVariant
216 * Locks @value for performing sensitive operations.
219 g_variant_lock (GVariant
*value
)
221 g_bit_lock (&value
->state
, 0);
226 * @value: a #GVariant
228 * Unlocks @value after performing sensitive operations.
231 g_variant_unlock (GVariant
*value
)
233 g_bit_unlock (&value
->state
, 0);
237 * g_variant_release_children:
238 * @value: a #GVariant
240 * Releases the reference held on each child in the 'children' array of
241 * @value and frees the array itself. @value must be in tree form.
243 * This is done when freeing a tree-form instance or converting it to
246 * The current thread must hold the lock on @value.
249 g_variant_release_children (GVariant
*value
)
253 g_assert (value
->state
& STATE_LOCKED
);
254 g_assert (~value
->state
& STATE_SERIALISED
);
256 for (i
= 0; i
< value
->contents
.tree
.n_children
; i
++)
257 g_variant_unref (value
->contents
.tree
.children
[i
]);
259 g_free (value
->contents
.tree
.children
);
262 /* This begins the main body of the recursive serialiser.
264 * There are 3 functions here that work as a team with the serialiser to
265 * get things done. g_variant_store() has a trivial role, but as a
266 * public API function, it has its definition elsewhere.
268 * Note that "serialisation" of an instance does not mean that the
269 * instance is converted to serialised form -- it means that the
270 * serialised form of an instance is written to an external buffer.
271 * g_variant_ensure_serialised() (which is not part of this set of
272 * functions) is the function that is responsible for converting an
273 * instance to serialised form.
275 * We are only concerned here with container types since non-container
276 * instances are always in serialised form. For these instances,
277 * storing their serialised form merely involves a memcpy().
279 * Serialisation is a two-step process. First, the size of the
280 * serialised data must be calculated so that an appropriately-sized
281 * buffer can be allocated. Second, the data is written into the
284 * Determining the size:
285 * The process of determining the size is triggered by a call to
286 * g_variant_ensure_size() on a container. This invokes the
287 * serialiser code to determine the size. The serialiser is passed
288 * g_variant_fill_gvs() as a callback.
290 * g_variant_fill_gvs() is called by the serialiser on each child of
291 * the container which, in turn, calls g_variant_ensure_size() on
292 * itself and fills in the result of its own size calculation.
294 * The serialiser uses the size information from the children to
295 * calculate the size needed for the entire container.
298 * After the buffer has been allocated, g_variant_serialise() is
299 * called on the container. This invokes the serialiser code to write
300 * the bytes to the container. The serialiser is, again, passed
301 * g_variant_fill_gvs() as a callback.
303 * This time, when g_variant_fill_gvs() is called for each child, the
304 * child is given a pointer to a sub-region of the allocated buffer
305 * where it should write its data. This is done by calling
306 * g_variant_store(). In the event that the instance is in serialised
307 * form this means a memcpy() of the serialised data into the
308 * allocated buffer. In the event that the instance is in tree form
309 * this means a recursive call back into g_variant_serialise().
312 * The forward declaration here allows corecursion via callback:
314 static void g_variant_fill_gvs (GVariantSerialised
*, gpointer
);
317 * g_variant_ensure_size:
318 * @value: a #GVariant
320 * Ensures that the ->size field of @value is filled in properly. This
321 * must be done as a precursor to any serialisation of the value in
322 * order to know how large of a buffer is needed to store the data.
324 * The current thread must hold the lock on @value.
327 g_variant_ensure_size (GVariant
*value
)
329 g_assert (value
->state
& STATE_LOCKED
);
331 if (value
->size
== (gssize
) -1)
336 children
= (gpointer
*) value
->contents
.tree
.children
;
337 n_children
= value
->contents
.tree
.n_children
;
338 value
->size
= g_variant_serialiser_needed_size (value
->type_info
,
340 children
, n_children
);
345 * g_variant_serialise:
346 * @value: a #GVariant
347 * @data: an appropriately-sized buffer
349 * Serialises @value into @data. @value must be in tree form.
351 * No change is made to @value.
353 * The current thread must hold the lock on @value.
356 g_variant_serialise (GVariant
*value
,
359 GVariantSerialised serialised
= { 0, };
363 g_assert (~value
->state
& STATE_SERIALISED
);
364 g_assert (value
->state
& STATE_LOCKED
);
366 serialised
.type_info
= value
->type_info
;
367 serialised
.size
= value
->size
;
368 serialised
.data
= data
;
370 children
= (gpointer
*) value
->contents
.tree
.children
;
371 n_children
= value
->contents
.tree
.n_children
;
373 g_variant_serialiser_serialise (serialised
, g_variant_fill_gvs
,
374 children
, n_children
);
378 * g_variant_fill_gvs:
379 * @serialised: a pointer to a #GVariantSerialised
380 * @data: a #GVariant instance
382 * This is the callback that is passed by a tree-form container instance
383 * to the serialiser. This callback gets called on each child of the
384 * container. Each child is responsible for performing the following
387 * - reporting its type
389 * - reporting its serialised size (requires knowing the size first)
391 * - possibly storing its serialised form into the provided buffer
394 g_variant_fill_gvs (GVariantSerialised
*serialised
,
397 GVariant
*value
= data
;
399 g_variant_lock (value
);
400 g_variant_ensure_size (value
);
401 g_variant_unlock (value
);
403 if (serialised
->type_info
== NULL
)
404 serialised
->type_info
= value
->type_info
;
405 g_assert (serialised
->type_info
== value
->type_info
);
407 if (serialised
->size
== 0)
408 serialised
->size
= value
->size
;
409 g_assert (serialised
->size
== value
->size
);
411 if (serialised
->data
)
412 /* g_variant_store() is a public API, so it
413 * it will reacquire the lock if it needs to.
415 g_variant_store (value
, serialised
->data
);
418 /* this ends the main body of the recursive serialiser */
421 * g_variant_ensure_serialised:
422 * @value: a #GVariant
424 * Ensures that @value is in serialised form.
426 * If @value is in tree form then this function ensures that the
427 * serialised size is known and then allocates a buffer of that size and
428 * serialises the instance into the buffer. The 'children' array is
429 * then released and the instance is set to serialised form based on the
430 * contents of the buffer.
432 * The current thread must hold the lock on @value.
435 g_variant_ensure_serialised (GVariant
*value
)
437 g_assert (value
->state
& STATE_LOCKED
);
439 if (~value
->state
& STATE_SERIALISED
)
444 g_variant_ensure_size (value
);
445 data
= g_malloc (value
->size
);
446 g_variant_serialise (value
, data
);
448 g_variant_release_children (value
);
450 buffer
= g_buffer_new_take_data (data
, value
->size
);
451 value
->contents
.serialised
.data
= buffer
->data
;
452 value
->contents
.serialised
.buffer
= buffer
;
453 value
->state
|= STATE_SERIALISED
;
459 * @type: the type of the new instance
460 * @serialised: if the instance will be in serialised form
461 * @trusted: if the instance will be trusted
462 * @returns: a new #GVariant with a floating reference
464 * Allocates a #GVariant instance and does some common work (such as
465 * looking up and filling in the type info), setting the state field,
466 * and setting the ref_count to 1.
469 g_variant_alloc (const GVariantType
*type
,
475 value
= g_slice_new (GVariant
);
476 value
->type_info
= g_variant_type_info_get (type
);
477 value
->state
= (serialised
? STATE_SERIALISED
: 0) |
478 (trusted
? STATE_TRUSTED
: 0) |
480 value
->size
= (gssize
) -1;
481 value
->ref_count
= 1;
488 * g_variant_new_from_buffer:
489 * @type: a #GVariantType
490 * @buffer: a #GBuffer
491 * @trusted: if the contents of @buffer are trusted
492 * @returns: a new #GVariant with a floating reference
494 * Constructs a new serialised-mode #GVariant instance. This is the
495 * inner interface for creation of new serialised values that gets
496 * called from various functions in gvariant.c.
498 * A reference is taken on @buffer.
501 g_variant_new_from_buffer (const GVariantType
*type
,
509 value
= g_variant_alloc (type
, TRUE
, trusted
);
511 value
->contents
.serialised
.buffer
= g_buffer_ref (buffer
);
513 g_variant_type_info_query (value
->type_info
,
516 if (size
&& buffer
->size
!= size
)
518 /* Creating a fixed-sized GVariant with a buffer of the wrong
521 * We should do the equivalent of pulling a fixed-sized child out
522 * of a brozen container (ie: data is NULL size is equal to the correct
525 value
->contents
.serialised
.data
= NULL
;
530 value
->contents
.serialised
.data
= buffer
->data
;
531 value
->size
= buffer
->size
;
538 * g_variant_new_from_children:
539 * @type: a #GVariantType
540 * @children: an array of #GVariant pointers. Consumed.
541 * @n_children: the length of @children
542 * @trusted: %TRUE if every child in @children in trusted
543 * @returns: a new #GVariant with a floating reference
545 * Constructs a new tree-mode #GVariant instance. This is the inner
546 * interface for creation of new serialised values that gets called from
547 * various functions in gvariant.c.
549 * @children is consumed by this function. g_free() will be called on
550 * it some time later.
553 g_variant_new_from_children (const GVariantType
*type
,
560 value
= g_variant_alloc (type
, FALSE
, trusted
);
561 value
->contents
.tree
.children
= children
;
562 value
->contents
.tree
.n_children
= n_children
;
568 * g_variant_get_type_info:
569 * @value: a #GVariant
570 * @returns: the #GVariantTypeInfo for @value
572 * Returns the #GVariantTypeInfo corresponding to the type of @value. A
573 * reference is not added, so the return value is only good for the
574 * duration of the life of @value.
577 g_variant_get_type_info (GVariant
*value
)
579 return value
->type_info
;
583 * g_variant_is_trusted:
584 * @value: a #GVariant
585 * @returns: if @value is trusted
587 * Determines if @value is trusted by #GVariant to contain only
588 * fully-valid data. All values constructed solely via #GVariant APIs
589 * are trusted, but values containing data read in from other sources
590 * are usually not trusted.
592 * The main advantage of trusted data is that certain checks can be
593 * skipped. For example, we don't need to check that a string is
594 * properly nul-terminated or that an object path is actually a
595 * properly-formatted object path.
598 g_variant_is_trusted (GVariant
*value
)
600 return (value
->state
& STATE_TRUSTED
) != 0;
607 * @value: a #GVariant
609 * Decreases the reference count of @value. When its reference count
610 * drops to 0, the memory used by the variant is freed.
615 g_variant_unref (GVariant
*value
)
617 if (g_atomic_int_dec_and_test (&value
->ref_count
))
619 if G_UNLIKELY (value
->state
& STATE_LOCKED
)
620 g_critical ("attempting to free a locked GVariant instance. "
621 "This should never happen.");
623 value
->state
|= STATE_LOCKED
;
625 g_variant_type_info_unref (value
->type_info
);
627 if (value
->state
& STATE_SERIALISED
)
628 g_buffer_unref (value
->contents
.serialised
.buffer
);
630 g_variant_release_children (value
);
632 memset (value
, 0, sizeof (GVariant
));
633 g_slice_free (GVariant
, value
);
639 * @value: a #GVariant
640 * @returns: the same @value
642 * Increases the reference count of @value.
647 g_variant_ref (GVariant
*value
)
649 g_atomic_int_inc (&value
->ref_count
);
655 * g_variant_ref_sink:
656 * @value: a #GVariant
657 * @returns: the same @value
659 * #GVariant uses a floating reference count system. All functions with
660 * names starting with <literal>g_variant_new_</literal> return floating
663 * Calling g_variant_ref_sink() on a #GVariant with a floating reference
664 * will convert the floating reference into a full reference. Calling
665 * g_variant_ref_sink() on a non-floating #GVariant results in an
666 * additional normal reference being added.
668 * In other words, if the @value is floating, then this call "assumes
669 * ownership" of the floating reference, converting it to a normal
670 * reference. If the @value is not floating, then this call adds a
671 * new normal reference increasing the reference count by one.
673 * All calls that result in a #GVariant instance being inserted into a
674 * container will call g_variant_ref_sink() on the instance. This means
675 * that if the value was just created (and has only its floating
676 * reference) then the container will assume sole ownership of the value
677 * at that point and the caller will not need to unreference it. This
678 * makes certain common styles of programming much easier while still
679 * maintaining normal refcounting semantics in situations where values
685 g_variant_ref_sink (GVariant
*value
)
687 g_variant_lock (value
);
689 if (~value
->state
& STATE_FLOATING
)
690 g_variant_ref (value
);
692 value
->state
&= ~STATE_FLOATING
;
694 g_variant_unlock (value
);
700 * g_variant_take_ref:
701 * @value: a #GVariant
702 * @returns: the same @value
704 * If @value is floating, sink it. Otherwise, do nothing.
706 * Typically you want to use g_variant_ref_sink() in order to
707 * automatically do the correct thing with respect to floating or
708 * non-floating references, but there is one specific scenario where
709 * this function is helpful.
711 * The situation where this function is helpful is when creating an API
712 * that allows the user to provide a callback function that returns a
713 * #GVariant. We certainly want to allow the user the flexibility to
714 * return a non-floating reference from this callback (for the case
715 * where the value that is being returned already exists).
717 * At the same time, the style of the #GVariant API makes it likely that
718 * for newly-created #GVariant instances, the user can be saved some
719 * typing if they are allowed to return a #GVariant with a floating
722 * Using this function on the return value of the user's callback allows
723 * the user to do whichever is more convenient for them. The caller
724 * will alway receives exactly one full reference to the value: either
725 * the one that was returned in the first place, or a floating reference
726 * that has been converted to a full reference.
728 * This function has an odd interaction when combined with
729 * g_variant_ref_sink() running at the same time in another thread on
730 * the same #GVariant instance. If g_variant_ref_sink() runs first then
731 * the result will be that the floating reference is converted to a hard
732 * reference. If g_variant_take_ref() runs first then the result will
733 * be that the floating reference is converted to a hard reference and
734 * an additional reference on top of that one is added. It is best to
735 * avoid this situation.
738 g_variant_take_ref (GVariant
*value
)
740 g_return_val_if_fail (value
!= NULL
, NULL
);
742 g_atomic_int_and (&value
->state
, ~STATE_FLOATING
);
748 * g_variant_is_floating:
749 * @value: a #GVariant
750 * @returns: whether @value is floating
752 * Checks whether @value has a floating reference count.
754 * This function should only ever be used to assert that a given variant
755 * is or is not floating, or for debug purposes. To acquire a reference
756 * to a variant that might be floating, always use g_variant_ref_sink()
757 * or g_variant_take_ref().
759 * See g_variant_ref_sink() for more information about floating reference
765 g_variant_is_floating (GVariant
*value
)
767 g_return_val_if_fail (value
!= NULL
, FALSE
);
769 return (value
->state
& STATE_FLOATING
) != 0;
773 * g_variant_get_size:
774 * @value: a #GVariant instance
775 * @returns: the serialised size of @value
777 * Determines the number of bytes that would be required to store @value
778 * with g_variant_store().
780 * If @value has a fixed-sized type then this function always returned
783 * In the case that @value is already in serialised form or the size has
784 * already been calculated (ie: this function has been called before)
785 * then this function is O(1). Otherwise, the size is calculated, an
786 * operation which is approximately O(n) in the number of values
792 g_variant_get_size (GVariant
*value
)
794 g_variant_lock (value
);
795 g_variant_ensure_size (value
);
796 g_variant_unlock (value
);
802 * g_variant_get_data:
803 * @value: a #GVariant instance
804 * @returns: (transfer none): the serialised form of @value, or %NULL
806 * Returns a pointer to the serialised form of a #GVariant instance.
807 * The returned data may not be in fully-normalised form if read from an
808 * untrusted source. The returned data must not be freed; it remains
809 * valid for as long as @value exists.
811 * If @value is a fixed-sized value that was deserialised from a
812 * corrupted serialised container then %NULL may be returned. In this
813 * case, the proper thing to do is typically to use the appropriate
814 * number of nul bytes in place of @value. If @value is not fixed-sized
815 * then %NULL is never returned.
817 * In the case that @value is already in serialised form, this function
818 * is O(1). If the value is not already in serialised form,
819 * serialisation occurs implicitly and is approximately O(n) in the size
825 g_variant_get_data (GVariant
*value
)
827 g_variant_lock (value
);
828 g_variant_ensure_serialised (value
);
829 g_variant_unlock (value
);
831 return value
->contents
.serialised
.data
;
835 * g_variant_n_children:
836 * @value: a container #GVariant
837 * @returns: the number of children in the container
839 * Determines the number of children in a container #GVariant instance.
840 * This includes variants, maybes, arrays, tuples and dictionary
841 * entries. It is an error to call this function on any other type of
844 * For variants, the return value is always 1. For values with maybe
845 * types, it is always zero or one. For arrays, it is the length of the
846 * array. For tuples it is the number of tuple items (which depends
847 * only on the type). For dictionary entries, it is always 2
849 * This function is O(1).
854 g_variant_n_children (GVariant
*value
)
858 g_variant_lock (value
);
860 if (value
->state
& STATE_SERIALISED
)
862 GVariantSerialised serialised
= {
864 (gpointer
) value
->contents
.serialised
.data
,
868 n_children
= g_variant_serialised_n_children (serialised
);
871 n_children
= value
->contents
.tree
.n_children
;
873 g_variant_unlock (value
);
879 * g_variant_get_child_value:
880 * @value: a container #GVariant
881 * @index_: the index of the child to fetch
882 * @returns: (transfer full): the child at the specified index
884 * Reads a child item out of a container #GVariant instance. This
885 * includes variants, maybes, arrays, tuples and dictionary
886 * entries. It is an error to call this function on any other type of
889 * It is an error if @index_ is greater than the number of child items
890 * in the container. See g_variant_n_children().
892 * This function is O(1).
897 g_variant_get_child_value (GVariant
*value
,
900 g_return_val_if_fail (index_
< g_variant_n_children (value
), NULL
);
902 if (~g_atomic_int_get (&value
->state
) & STATE_SERIALISED
)
904 g_variant_lock (value
);
906 if (~value
->state
& STATE_SERIALISED
)
910 child
= g_variant_ref (value
->contents
.tree
.children
[index_
]);
911 g_variant_unlock (value
);
916 g_variant_unlock (value
);
920 GVariantSerialised serialised
= {
922 (gpointer
) value
->contents
.serialised
.data
,
925 GVariantSerialised s_child
;
928 /* get the serialiser to extract the serialised data for the child
929 * from the serialised data for the container
931 s_child
= g_variant_serialised_get_child (serialised
, index_
);
933 /* create a new serialised instance out of it */
934 child
= g_slice_new (GVariant
);
935 child
->type_info
= s_child
.type_info
;
936 child
->state
= (value
->state
& STATE_TRUSTED
) |
938 child
->size
= s_child
.size
;
939 child
->ref_count
= 1;
940 child
->contents
.serialised
.buffer
=
941 g_buffer_ref (value
->contents
.serialised
.buffer
);
942 child
->contents
.serialised
.data
= s_child
.data
;
950 * @value: the #GVariant to store
951 * @data: the location to store the serialised data at
953 * Stores the serialised form of @value at @data. @data should be
954 * large enough. See g_variant_get_size().
956 * The stored data is in machine native byte order but may not be in
957 * fully-normalised form if read from an untrusted source. See
958 * g_variant_get_normal_form() for a solution.
960 * This function is approximately O(n) in the size of @data.
965 g_variant_store (GVariant
*value
,
968 g_variant_lock (value
);
970 if (value
->state
& STATE_SERIALISED
)
972 if (value
->contents
.serialised
.data
!= NULL
)
973 memcpy (data
, value
->contents
.serialised
.data
, value
->size
);
975 memset (data
, 0, value
->size
);
978 g_variant_serialise (value
, data
);
980 g_variant_unlock (value
);
984 * g_variant_is_normal_form:
985 * @value: a #GVariant instance
986 * @returns: %TRUE if @value is in normal form
988 * Checks if @value is in normal form.
990 * The main reason to do this is to detect if a given chunk of
991 * serialised data is in normal form: load the data into a #GVariant
992 * using g_variant_new_from_data() and then use this function to
995 * If @value is found to be in normal form then it will be marked as
996 * being trusted. If the value was already marked as being trusted then
997 * this function will immediately return %TRUE.
1002 g_variant_is_normal_form (GVariant
*value
)
1004 if (value
->state
& STATE_TRUSTED
)
1007 g_variant_lock (value
);
1009 if (value
->state
& STATE_SERIALISED
)
1011 GVariantSerialised serialised
= {
1013 (gpointer
) value
->contents
.serialised
.data
,
1017 if (g_variant_serialised_is_normal (serialised
))
1018 value
->state
|= STATE_TRUSTED
;
1022 gboolean normal
= TRUE
;
1025 for (i
= 0; i
< value
->contents
.tree
.n_children
; i
++)
1026 normal
&= g_variant_is_normal_form (value
->contents
.tree
.children
[i
]);
1029 value
->state
|= STATE_TRUSTED
;
1032 g_variant_unlock (value
);
1034 return (value
->state
& STATE_TRUSTED
) != 0;