nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright © 2007, 2008 Ryan Lortie
3 * Copyright © 2010 Codethink Limited
4 *
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.
9 *
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.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 *
18 * Author: Ryan Lortie <desrt@desrt.ca>
19 */
20  
21 /* Prologue {{{1 */
22 #include "config.h"
23  
24 #include "gvariant-serialiser.h"
25  
26 #include <glib/gtestutils.h>
27 #include <glib/gstrfuncs.h>
28 #include <glib/gtypes.h>
29  
30 #include <string.h>
31  
32  
33 /* GVariantSerialiser
34 *
35 * After this prologue section, this file has roughly 2 parts.
36 *
37 * The first part is split up into sections according to various
38 * container types. Maybe, Array, Tuple, Variant. The Maybe and Array
39 * sections are subdivided for element types being fixed or
40 * variable-sized types.
41 *
42 * Each section documents the format of that particular type of
43 * container and implements 5 functions for dealing with it:
44 *
45 * n_children:
46 * - determines (according to serialised data) how many child values
47 * are inside a particular container value.
48 *
49 * get_child:
50 * - gets the type of and the serialised data corresponding to a
51 * given child value within the container value.
52 *
53 * needed_size:
54 * - determines how much space would be required to serialise a
55 * container of this type, containing the given children so that
56 * buffers can be preallocated before serialising.
57 *
58 * serialise:
59 * - write the serialised data for a container of this type,
60 * containing the given children, to a buffer.
61 *
62 * is_normal:
63 * - check the given data to ensure that it is in normal form. For a
64 * given set of child values, there is exactly one normal form for
65 * the serialised data of a container. Other forms are possible
66 * while maintaining the same children (for example, by inserting
67 * something other than zero bytes as padding) but only one form is
68 * the normal form.
69 *
70 * The second part contains the main entry point for each of the above 5
71 * functions and logic to dispatch it to the handler for the appropriate
72 * container type code.
73 *
74 * The second part also contains a routine to byteswap serialised
75 * values. This code makes use of the n_children() and get_child()
76 * functions above to do its work so no extra support is needed on a
77 * per-container-type basis.
78 *
79 * There is also additional code for checking for normal form. All
80 * numeric types are always in normal form since the full range of
81 * values is permitted (eg: 0 to 255 is a valid byte). Special checks
82 * need to be performed for booleans (only 0 or 1 allowed), strings
83 * (properly nul-terminated) and object paths and signature strings
84 * (meeting the D-Bus specification requirements).
85 */
86  
87 /* < private >
88 * GVariantSerialised:
89 * @type_info: the #GVariantTypeInfo of this value
90 * @data: (allow-none): the serialised data of this value, or %NULL
91 * @size: the size of this value
92 *
93 * A structure representing a GVariant in serialised form. This
94 * structure is used with #GVariantSerialisedFiller functions and as the
95 * primary interface to the serialiser. See #GVariantSerialisedFiller
96 * for a description of its use there.
97 *
98 * When used with the serialiser API functions, the following invariants
99 * apply to all #GVariantTypeSerialised structures passed to and
100 * returned from the serialiser.
101 *
102 * @type_info must be non-%NULL.
103 *
104 * @data must be properly aligned for the type described by @type_info.
105 *
106 * If @type_info describes a fixed-sized type then @size must always be
107 * equal to the fixed size of that type.
108 *
109 * For fixed-sized types (and only fixed-sized types), @data may be
110 * %NULL even if @size is non-zero. This happens when a framing error
111 * occurs while attempting to extract a fixed-sized value out of a
112 * variable-sized container. There is no data to return for the
113 * fixed-sized type, yet @size must be non-zero. The effect of this
114 * combination should be as if @data were a pointer to an
115 * appropriately-sized zero-filled region.
116 */
117  
118 /* < private >
119 * g_variant_serialised_check:
120 * @serialised: a #GVariantSerialised struct
121 *
122 * Checks @serialised for validity according to the invariants described
123 * above.
124 */
125 static void
126 g_variant_serialised_check (GVariantSerialised serialised)
127 {
128 gsize fixed_size;
129 guint alignment;
130  
131 g_assert (serialised.type_info != NULL);
132 g_variant_type_info_query (serialised.type_info, &alignment, &fixed_size);
133  
134 if (fixed_size)
135 g_assert_cmpint (serialised.size, ==, fixed_size);
136 else
137 g_assert (serialised.size == 0 || serialised.data != NULL);
138  
139 /* Depending on the native alignment requirements of the machine, the
140 * compiler will insert either 3 or 7 padding bytes after the char.
141 * This will result in the sizeof() the struct being 12 or 16.
142 * Subtract 9 to get 3 or 7 which is a nice bitmask to apply to get
143 * the alignment bits that we "care about" being zero: in the
144 * 4-aligned case, we care about 2 bits, and in the 8-aligned case, we
145 * care about 3 bits.
146 */
147 alignment &= sizeof (struct {
148 char a;
149 union {
150 guint64 x;
151 void *y;
152 gdouble z;
153 } b;
154 }
155 ) - 9;
156  
157 /* Some OSes (FreeBSD is a known example) have a malloc() that returns
158 * unaligned memory if you request small sizes. 'malloc (1);', for
159 * example, has been seen to return pointers aligned to 6 mod 16.
160 *
161 * Check if this is a small allocation and return without enforcing
162 * the alignment assertion if this is the case.
163 */
164 if (serialised.size <= alignment)
165 return;
166  
167 g_assert_cmpint (alignment & (gsize) serialised.data, ==, 0);
168 }
169  
170 /* < private >
171 * GVariantSerialisedFiller:
172 * @serialised: a #GVariantSerialised instance to fill
173 * @data: data from the children array
174 *
175 * This function is called back from g_variant_serialiser_needed_size()
176 * and g_variant_serialiser_serialise(). It fills in missing details
177 * from a partially-complete #GVariantSerialised.
178 *
179 * The @data parameter passed back to the function is one of the items
180 * that was passed to the serialiser in the @children array. It
181 * represents a single child item of the container that is being
182 * serialised. The information filled in to @serialised is the
183 * information for this child.
184 *
185 * If the @type_info field of @serialised is %NULL then the callback
186 * function must set it to the type information corresponding to the
187 * type of the child. No reference should be added. If it is non-%NULL
188 * then the callback should assert that it is equal to the actual type
189 * of the child.
190 *
191 * If the @size field is zero then the callback must fill it in with the
192 * required amount of space to store the serialised form of the child.
193 * If it is non-zero then the callback should assert that it is equal to
194 * the needed size of the child.
195 *
196 * If @data is non-%NULL then it points to a space that is properly
197 * aligned for and large enough to store the serialised data of the
198 * child. The callback must store the serialised form of the child at
199 * @data.
200 *
201 * If the child value is another container then the callback will likely
202 * recurse back into the serialiser by calling
203 * g_variant_serialiser_needed_size() to determine @size and
204 * g_variant_serialiser_serialise() to write to @data.
205 */
206  
207 /* PART 1: Container types {{{1
208 *
209 * This section contains the serialiser implementation functions for
210 * each container type.
211 */
212  
213 /* Maybe {{{2
214 *
215 * Maybe types are handled depending on if the element type of the maybe
216 * type is a fixed-sized or variable-sized type. Although all maybe
217 * types themselves are variable-sized types, herein, a maybe value with
218 * a fixed-sized element type is called a "fixed-sized maybe" for
219 * convenience and a maybe value with a variable-sized element type is
220 * called a "variable-sized maybe".
221 */
222  
223 /* Fixed-sized Maybe {{{3
224 *
225 * The size of a maybe value with a fixed-sized element type is either 0
226 * or equal to the fixed size of its element type. The case where the
227 * size of the maybe value is zero corresponds to the "Nothing" case and
228 * the case where the size of the maybe value is equal to the fixed size
229 * of the element type corresponds to the "Just" case; in that case, the
230 * serialised data of the child value forms the entire serialised data
231 * of the maybe value.
232 *
233 * In the event that a fixed-sized maybe value is presented with a size
234 * that is not equal to the fixed size of the element type then the
235 * value must be taken to be "Nothing".
236 */
237  
238 static gsize
239 gvs_fixed_sized_maybe_n_children (GVariantSerialised value)
240 {
241 gsize element_fixed_size;
242  
243 g_variant_type_info_query_element (value.type_info, NULL,
244 &element_fixed_size);
245  
246 return (element_fixed_size == value.size) ? 1 : 0;
247 }
248  
249 static GVariantSerialised
250 gvs_fixed_sized_maybe_get_child (GVariantSerialised value,
251 gsize index_)
252 {
253 /* the child has the same bounds as the
254 * container, so just update the type.
255 */
256 value.type_info = g_variant_type_info_element (value.type_info);
257 g_variant_type_info_ref (value.type_info);
258  
259 return value;
260 }
261  
262 static gsize
263 gvs_fixed_sized_maybe_needed_size (GVariantTypeInfo *type_info,
264 GVariantSerialisedFiller gvs_filler,
265 const gpointer *children,
266 gsize n_children)
267 {
268 if (n_children)
269 {
270 gsize element_fixed_size;
271  
272 g_variant_type_info_query_element (type_info, NULL,
273 &element_fixed_size);
274  
275 return element_fixed_size;
276 }
277 else
278 return 0;
279 }
280  
281 static void
282 gvs_fixed_sized_maybe_serialise (GVariantSerialised value,
283 GVariantSerialisedFiller gvs_filler,
284 const gpointer *children,
285 gsize n_children)
286 {
287 if (n_children)
288 {
289 GVariantSerialised child = { NULL, value.data, value.size };
290  
291 gvs_filler (&child, children[0]);
292 }
293 }
294  
295 static gboolean
296 gvs_fixed_sized_maybe_is_normal (GVariantSerialised value)
297 {
298 if (value.size > 0)
299 {
300 gsize element_fixed_size;
301  
302 g_variant_type_info_query_element (value.type_info,
303 NULL, &element_fixed_size);
304  
305 if (value.size != element_fixed_size)
306 return FALSE;
307  
308 /* proper element size: "Just". recurse to the child. */
309 value.type_info = g_variant_type_info_element (value.type_info);
310  
311 return g_variant_serialised_is_normal (value);
312 }
313  
314 /* size of 0: "Nothing" */
315 return TRUE;
316 }
317  
318 /* Variable-sized Maybe
319 *
320 * The size of a maybe value with a variable-sized element type is
321 * either 0 or strictly greater than 0. The case where the size of the
322 * maybe value is zero corresponds to the "Nothing" case and the case
323 * where the size of the maybe value is greater than zero corresponds to
324 * the "Just" case; in that case, the serialised data of the child value
325 * forms the first part of the serialised data of the maybe value and is
326 * followed by a single zero byte. This zero byte is always appended,
327 * regardless of any zero bytes that may already be at the end of the
328 * serialised ata of the child value.
329 */
330  
331 static gsize
332 gvs_variable_sized_maybe_n_children (GVariantSerialised value)
333 {
334 return (value.size > 0) ? 1 : 0;
335 }
336  
337 static GVariantSerialised
338 gvs_variable_sized_maybe_get_child (GVariantSerialised value,
339 gsize index_)
340 {
341 /* remove the padding byte and update the type. */
342 value.type_info = g_variant_type_info_element (value.type_info);
343 g_variant_type_info_ref (value.type_info);
344 value.size--;
345  
346 /* if it's zero-sized then it may as well be NULL */
347 if (value.size == 0)
348 value.data = NULL;
349  
350 return value;
351 }
352  
353 static gsize
354 gvs_variable_sized_maybe_needed_size (GVariantTypeInfo *type_info,
355 GVariantSerialisedFiller gvs_filler,
356 const gpointer *children,
357 gsize n_children)
358 {
359 if (n_children)
360 {
361 GVariantSerialised child = { 0, };
362  
363 gvs_filler (&child, children[0]);
364  
365 return child.size + 1;
366 }
367 else
368 return 0;
369 }
370  
371 static void
372 gvs_variable_sized_maybe_serialise (GVariantSerialised value,
373 GVariantSerialisedFiller gvs_filler,
374 const gpointer *children,
375 gsize n_children)
376 {
377 if (n_children)
378 {
379 GVariantSerialised child = { NULL, value.data, value.size - 1 };
380  
381 /* write the data for the child. */
382 gvs_filler (&child, children[0]);
383 value.data[child.size] = '\0';
384 }
385 }
386  
387 static gboolean
388 gvs_variable_sized_maybe_is_normal (GVariantSerialised value)
389 {
390 if (value.size == 0)
391 return TRUE;
392  
393 if (value.data[value.size - 1] != '\0')
394 return FALSE;
395  
396 value.type_info = g_variant_type_info_element (value.type_info);
397 value.size--;
398  
399 return g_variant_serialised_is_normal (value);
400 }
401  
402 /* Arrays {{{2
403 *
404 * Just as with maybe types, array types are handled depending on if the
405 * element type of the array type is a fixed-sized or variable-sized
406 * type. Similar to maybe types, for convenience, an array value with a
407 * fixed-sized element type is called a "fixed-sized array" and an array
408 * value with a variable-sized element type is called a "variable sized
409 * array".
410 */
411  
412 /* Fixed-sized Array {{{3
413 *
414 * For fixed sized arrays, the serialised data is simply a concatenation
415 * of the serialised data of each element, in order. Since fixed-sized
416 * values always have a fixed size that is a multiple of their alignment
417 * requirement no extra padding is required.
418 *
419 * In the event that a fixed-sized array is presented with a size that
420 * is not an integer multiple of the element size then the value of the
421 * array must be taken as being empty.
422 */
423  
424 static gsize
425 gvs_fixed_sized_array_n_children (GVariantSerialised value)
426 {
427 gsize element_fixed_size;
428  
429 g_variant_type_info_query_element (value.type_info, NULL,
430 &element_fixed_size);
431  
432 if (value.size % element_fixed_size == 0)
433 return value.size / element_fixed_size;
434  
435 return 0;
436 }
437  
438 static GVariantSerialised
439 gvs_fixed_sized_array_get_child (GVariantSerialised value,
440 gsize index_)
441 {
442 GVariantSerialised child = { 0, };
443  
444 child.type_info = g_variant_type_info_element (value.type_info);
445 g_variant_type_info_query (child.type_info, NULL, &child.size);
446 child.data = value.data + (child.size * index_);
447 g_variant_type_info_ref (child.type_info);
448  
449 return child;
450 }
451  
452 static gsize
453 gvs_fixed_sized_array_needed_size (GVariantTypeInfo *type_info,
454 GVariantSerialisedFiller gvs_filler,
455 const gpointer *children,
456 gsize n_children)
457 {
458 gsize element_fixed_size;
459  
460 g_variant_type_info_query_element (type_info, NULL, &element_fixed_size);
461  
462 return element_fixed_size * n_children;
463 }
464  
465 static void
466 gvs_fixed_sized_array_serialise (GVariantSerialised value,
467 GVariantSerialisedFiller gvs_filler,
468 const gpointer *children,
469 gsize n_children)
470 {
471 GVariantSerialised child = { 0, };
472 gsize i;
473  
474 child.type_info = g_variant_type_info_element (value.type_info);
475 g_variant_type_info_query (child.type_info, NULL, &child.size);
476 child.data = value.data;
477  
478 for (i = 0; i < n_children; i++)
479 {
480 gvs_filler (&child, children[i]);
481 child.data += child.size;
482 }
483 }
484  
485 static gboolean
486 gvs_fixed_sized_array_is_normal (GVariantSerialised value)
487 {
488 GVariantSerialised child = { 0, };
489  
490 child.type_info = g_variant_type_info_element (value.type_info);
491 g_variant_type_info_query (child.type_info, NULL, &child.size);
492  
493 if (value.size % child.size != 0)
494 return FALSE;
495  
496 for (child.data = value.data;
497 child.data < value.data + value.size;
498 child.data += child.size)
499 {
500 if (!g_variant_serialised_is_normal (child))
501 return FALSE;
502 }
503  
504 return TRUE;
505 }
506  
507 /* Variable-sized Array {{{3
508 *
509 * Variable sized arrays, containing variable-sized elements, must be
510 * able to determine the boundaries between the elements. The items
511 * cannot simply be concatenated. Additionally, we are faced with the
512 * fact that non-fixed-sized values do not necessarily have a size that
513 * is a multiple of their alignment requirement, so we may need to
514 * insert zero-filled padding.
515 *
516 * While it is possible to find the start of an item by starting from
517 * the end of the item before it and padding for alignment, it is not
518 * generally possible to do the reverse operation. For this reason, we
519 * record the end point of each element in the array.
520 *
521 * GVariant works in terms of "offsets". An offset is a pointer to a
522 * boundary between two bytes. In 4 bytes of serialised data, there
523 * would be 5 possible offsets: one at the start ('0'), one between each
524 * pair of adjacent bytes ('1', '2', '3') and one at the end ('4').
525 *
526 * The numeric value of an offset is an unsigned integer given relative
527 * to the start of the serialised data of the array. Offsets are always
528 * stored in little endian byte order and are always only as big as they
529 * need to be. For example, in 255 bytes of serialised data, there are
530 * 256 offsets. All possibilities can be stored in an 8 bit unsigned
531 * integer. In 256 bytes of serialised data, however, there are 257
532 * possible offsets so 16 bit integers must be used. The size of an
533 * offset is always a power of 2.
534 *
535 * The offsets are stored at the end of the serialised data of the
536 * array. They are simply concatenated on without any particular
537 * alignment. The size of the offsets is included in the size of the
538 * serialised data for purposes of determining the size of the offsets.
539 * This presents a possibly ambiguity; in certain cases, a particular
540 * value of array could have two different serialised forms.
541 *
542 * Imagine an array containing a single string of 253 bytes in length
543 * (so, 254 bytes including the nul terminator). Now the offset must be
544 * written. If an 8 bit offset is written, it will bring the size of
545 * the array's serialised data to 255 -- which means that the use of an
546 * 8 bit offset was valid. If a 16 bit offset is used then the total
547 * size of the array will be 256 -- which means that the use of a 16 bit
548 * offset was valid. Although both of these will be accepted by the
549 * deserialiser, only the smaller of the two is considered to be in
550 * normal form and that is the one that the serialiser must produce.
551 */
552  
553 /* bytes may be NULL if (size == 0). */
554 static inline gsize
555 gvs_read_unaligned_le (guchar *bytes,
556 guint size)
557 {
558 union
559 {
560 guchar bytes[GLIB_SIZEOF_SIZE_T];
561 gsize integer;
562 } tmpvalue;
563  
564 tmpvalue.integer = 0;
565 if (bytes != NULL)
566 memcpy (&tmpvalue.bytes, bytes, size);
567  
568 return GSIZE_FROM_LE (tmpvalue.integer);
569 }
570  
571 static inline void
572 gvs_write_unaligned_le (guchar *bytes,
573 gsize value,
574 guint size)
575 {
576 union
577 {
578 guchar bytes[GLIB_SIZEOF_SIZE_T];
579 gsize integer;
580 } tmpvalue;
581  
582 tmpvalue.integer = GSIZE_TO_LE (value);
583 memcpy (bytes, &tmpvalue.bytes, size);
584 }
585  
586 static guint
587 gvs_get_offset_size (gsize size)
588 {
589 if (size > G_MAXUINT32)
590 return 8;
591  
592 else if (size > G_MAXUINT16)
593 return 4;
594  
595 else if (size > G_MAXUINT8)
596 return 2;
597  
598 else if (size > 0)
599 return 1;
600  
601 return 0;
602 }
603  
604 static gsize
605 gvs_calculate_total_size (gsize body_size,
606 gsize offsets)
607 {
608 if (body_size + 1 * offsets <= G_MAXUINT8)
609 return body_size + 1 * offsets;
610  
611 if (body_size + 2 * offsets <= G_MAXUINT16)
612 return body_size + 2 * offsets;
613  
614 if (body_size + 4 * offsets <= G_MAXUINT32)
615 return body_size + 4 * offsets;
616  
617 return body_size + 8 * offsets;
618 }
619  
620 static gsize
621 gvs_variable_sized_array_n_children (GVariantSerialised value)
622 {
623 gsize offsets_array_size;
624 gsize offset_size;
625 gsize last_end;
626  
627 if (value.size == 0)
628 return 0;
629  
630 offset_size = gvs_get_offset_size (value.size);
631  
632 last_end = gvs_read_unaligned_le (value.data + value.size -
633 offset_size, offset_size);
634  
635 if (last_end > value.size)
636 return 0;
637  
638 offsets_array_size = value.size - last_end;
639  
640 if (offsets_array_size % offset_size)
641 return 0;
642  
643 return offsets_array_size / offset_size;
644 }
645  
646 static GVariantSerialised
647 gvs_variable_sized_array_get_child (GVariantSerialised value,
648 gsize index_)
649 {
650 GVariantSerialised child = { 0, };
651 gsize offset_size;
652 gsize last_end;
653 gsize start;
654 gsize end;
655  
656 child.type_info = g_variant_type_info_element (value.type_info);
657 g_variant_type_info_ref (child.type_info);
658  
659 offset_size = gvs_get_offset_size (value.size);
660  
661 last_end = gvs_read_unaligned_le (value.data + value.size -
662 offset_size, offset_size);
663  
664 if (index_ > 0)
665 {
666 guint alignment;
667  
668 start = gvs_read_unaligned_le (value.data + last_end +
669 (offset_size * (index_ - 1)),
670 offset_size);
671  
672 g_variant_type_info_query (child.type_info, &alignment, NULL);
673 start += (-start) & alignment;
674 }
675 else
676 start = 0;
677  
678 end = gvs_read_unaligned_le (value.data + last_end +
679 (offset_size * index_),
680 offset_size);
681  
682 if (start < end && end <= value.size)
683 {
684 child.data = value.data + start;
685 child.size = end - start;
686 }
687  
688 return child;
689 }
690  
691 static gsize
692 gvs_variable_sized_array_needed_size (GVariantTypeInfo *type_info,
693 GVariantSerialisedFiller gvs_filler,
694 const gpointer *children,
695 gsize n_children)
696 {
697 guint alignment;
698 gsize offset;
699 gsize i;
700  
701 g_variant_type_info_query (type_info, &alignment, NULL);
702 offset = 0;
703  
704 for (i = 0; i < n_children; i++)
705 {
706 GVariantSerialised child = { 0, };
707  
708 offset += (-offset) & alignment;
709 gvs_filler (&child, children[i]);
710 offset += child.size;
711 }
712  
713 return gvs_calculate_total_size (offset, n_children);
714 }
715  
716 static void
717 gvs_variable_sized_array_serialise (GVariantSerialised value,
718 GVariantSerialisedFiller gvs_filler,
719 const gpointer *children,
720 gsize n_children)
721 {
722 guchar *offset_ptr;
723 gsize offset_size;
724 guint alignment;
725 gsize offset;
726 gsize i;
727  
728 g_variant_type_info_query (value.type_info, &alignment, NULL);
729 offset_size = gvs_get_offset_size (value.size);
730 offset = 0;
731  
732 offset_ptr = value.data + value.size - offset_size * n_children;
733  
734 for (i = 0; i < n_children; i++)
735 {
736 GVariantSerialised child = { 0, };
737  
738 while (offset & alignment)
739 value.data[offset++] = '\0';
740  
741 child.data = value.data + offset;
742 gvs_filler (&child, children[i]);
743 offset += child.size;
744  
745 gvs_write_unaligned_le (offset_ptr, offset, offset_size);
746 offset_ptr += offset_size;
747 }
748 }
749  
750 static gboolean
751 gvs_variable_sized_array_is_normal (GVariantSerialised value)
752 {
753 GVariantSerialised child = { 0, };
754 gsize offsets_array_size;
755 guchar *offsets_array;
756 guint offset_size;
757 guint alignment;
758 gsize last_end;
759 gsize length;
760 gsize offset;
761 gsize i;
762  
763 if (value.size == 0)
764 return TRUE;
765  
766 offset_size = gvs_get_offset_size (value.size);
767 last_end = gvs_read_unaligned_le (value.data + value.size -
768 offset_size, offset_size);
769  
770 if (last_end > value.size)
771 return FALSE;
772  
773 offsets_array_size = value.size - last_end;
774  
775 if (offsets_array_size % offset_size)
776 return FALSE;
777  
778 offsets_array = value.data + value.size - offsets_array_size;
779 length = offsets_array_size / offset_size;
780  
781 if (length == 0)
782 return FALSE;
783  
784 child.type_info = g_variant_type_info_element (value.type_info);
785 g_variant_type_info_query (child.type_info, &alignment, NULL);
786 offset = 0;
787  
788 for (i = 0; i < length; i++)
789 {
790 gsize this_end;
791  
792 this_end = gvs_read_unaligned_le (offsets_array + offset_size * i,
793 offset_size);
794  
795 if (this_end < offset || this_end > last_end)
796 return FALSE;
797  
798 while (offset & alignment)
799 {
800 if (!(offset < this_end && value.data[offset] == '\0'))
801 return FALSE;
802 offset++;
803 }
804  
805 child.data = value.data + offset;
806 child.size = this_end - offset;
807  
808 if (child.size == 0)
809 child.data = NULL;
810  
811 if (!g_variant_serialised_is_normal (child))
812 return FALSE;
813  
814 offset = this_end;
815 }
816  
817 g_assert (offset == last_end);
818  
819 return TRUE;
820 }
821  
822 /* Tuples {{{2
823 *
824 * Since tuples can contain a mix of variable- and fixed-sized items,
825 * they are, in terms of serialisation, a hybrid of variable-sized and
826 * fixed-sized arrays.
827 *
828 * Offsets are only stored for variable-sized items. Also, since the
829 * number of items in a tuple is known from its type, we are able to
830 * know exactly how many offsets to expect in the serialised data (and
831 * therefore how much space is taken up by the offset array). This
832 * means that we know where the end of the serialised data for the last
833 * item is -- we can just subtract the size of the offset array from the
834 * total size of the tuple. For this reason, the last item in the tuple
835 * doesn't need an offset stored.
836 *
837 * Tuple offsets are stored in reverse. This design choice allows
838 * iterator-based deserialisers to be more efficient.
839 *
840 * Most of the "heavy lifting" here is handled by the GVariantTypeInfo
841 * for the tuple. See the notes in gvarianttypeinfo.h.
842 */
843  
844 static gsize
845 gvs_tuple_n_children (GVariantSerialised value)
846 {
847 return g_variant_type_info_n_members (value.type_info);
848 }
849  
850 static GVariantSerialised
851 gvs_tuple_get_child (GVariantSerialised value,
852 gsize index_)
853 {
854 const GVariantMemberInfo *member_info;
855 GVariantSerialised child = { 0, };
856 gsize offset_size;
857 gsize start, end;
858  
859 member_info = g_variant_type_info_member_info (value.type_info, index_);
860 child.type_info = g_variant_type_info_ref (member_info->type_info);
861 offset_size = gvs_get_offset_size (value.size);
862  
863 /* tuples are the only (potentially) fixed-sized containers, so the
864 * only ones that have to deal with the possibility of having %NULL
865 * data with a non-zero %size if errors occurred elsewhere.
866 */
867 if G_UNLIKELY (value.data == NULL && value.size != 0)
868 {
869 g_variant_type_info_query (child.type_info, NULL, &child.size);
870  
871 /* this can only happen in fixed-sized tuples,
872 * so the child must also be fixed sized.
873 */
874 g_assert (child.size != 0);
875 child.data = NULL;
876  
877 return child;
878 }
879  
880 if (member_info->ending_type == G_VARIANT_MEMBER_ENDING_OFFSET)
881 {
882 if (offset_size * (member_info->i + 2) > value.size)
883 return child;
884 }
885 else
886 {
887 if (offset_size * (member_info->i + 1) > value.size)
888 {
889 /* if the child is fixed size, return its size.
890 * if child is not fixed-sized, return size = 0.
891 */
892 g_variant_type_info_query (child.type_info, NULL, &child.size);
893  
894 return child;
895 }
896 }
897  
898 if (member_info->i + 1)
899 start = gvs_read_unaligned_le (value.data + value.size -
900 offset_size * (member_info->i + 1),
901 offset_size);
902 else
903 start = 0;
904  
905 start += member_info->a;
906 start &= member_info->b;
907 start |= member_info->c;
908  
909 if (member_info->ending_type == G_VARIANT_MEMBER_ENDING_LAST)
910 end = value.size - offset_size * (member_info->i + 1);
911  
912 else if (member_info->ending_type == G_VARIANT_MEMBER_ENDING_FIXED)
913 {
914 gsize fixed_size;
915  
916 g_variant_type_info_query (child.type_info, NULL, &fixed_size);
917 end = start + fixed_size;
918 child.size = fixed_size;
919 }
920  
921 else /* G_VARIANT_MEMBER_ENDING_OFFSET */
922 end = gvs_read_unaligned_le (value.data + value.size -
923 offset_size * (member_info->i + 2),
924 offset_size);
925  
926 if (start < end && end <= value.size)
927 {
928 child.data = value.data + start;
929 child.size = end - start;
930 }
931  
932 return child;
933 }
934  
935 static gsize
936 gvs_tuple_needed_size (GVariantTypeInfo *type_info,
937 GVariantSerialisedFiller gvs_filler,
938 const gpointer *children,
939 gsize n_children)
940 {
941 const GVariantMemberInfo *member_info = NULL;
942 gsize fixed_size;
943 gsize offset;
944 gsize i;
945  
946 g_variant_type_info_query (type_info, NULL, &fixed_size);
947  
948 if (fixed_size)
949 return fixed_size;
950  
951 offset = 0;
952  
953 for (i = 0; i < n_children; i++)
954 {
955 guint alignment;
956  
957 member_info = g_variant_type_info_member_info (type_info, i);
958 g_variant_type_info_query (member_info->type_info,
959 &alignment, &fixed_size);
960 offset += (-offset) & alignment;
961  
962 if (fixed_size)
963 offset += fixed_size;
964 else
965 {
966 GVariantSerialised child = { 0, };
967  
968 gvs_filler (&child, children[i]);
969 offset += child.size;
970 }
971 }
972  
973 return gvs_calculate_total_size (offset, member_info->i + 1);
974 }
975  
976 static void
977 gvs_tuple_serialise (GVariantSerialised value,
978 GVariantSerialisedFiller gvs_filler,
979 const gpointer *children,
980 gsize n_children)
981 {
982 gsize offset_size;
983 gsize offset;
984 gsize i;
985  
986 offset_size = gvs_get_offset_size (value.size);
987 offset = 0;
988  
989 for (i = 0; i < n_children; i++)
990 {
991 const GVariantMemberInfo *member_info;
992 GVariantSerialised child = { 0, };
993 guint alignment;
994  
995 member_info = g_variant_type_info_member_info (value.type_info, i);
996 g_variant_type_info_query (member_info->type_info, &alignment, NULL);
997  
998 while (offset & alignment)
999 value.data[offset++] = '\0';
1000  
1001 child.data = value.data + offset;
1002 gvs_filler (&child, children[i]);
1003 offset += child.size;
1004  
1005 if (member_info->ending_type == G_VARIANT_MEMBER_ENDING_OFFSET)
1006 {
1007 value.size -= offset_size;
1008 gvs_write_unaligned_le (value.data + value.size,
1009 offset, offset_size);
1010 }
1011 }
1012  
1013 while (offset < value.size)
1014 value.data[offset++] = '\0';
1015 }
1016  
1017 static gboolean
1018 gvs_tuple_is_normal (GVariantSerialised value)
1019 {
1020 guint offset_size;
1021 gsize offset_ptr;
1022 gsize length;
1023 gsize offset;
1024 gsize i;
1025  
1026 /* as per the comment in gvs_tuple_get_child() */
1027 if G_UNLIKELY (value.data == NULL && value.size != 0)
1028 return FALSE;
1029  
1030 offset_size = gvs_get_offset_size (value.size);
1031 length = g_variant_type_info_n_members (value.type_info);
1032 offset_ptr = value.size;
1033 offset = 0;
1034  
1035 for (i = 0; i < length; i++)
1036 {
1037 const GVariantMemberInfo *member_info;
1038 GVariantSerialised child;
1039 gsize fixed_size;
1040 guint alignment;
1041 gsize end;
1042  
1043 member_info = g_variant_type_info_member_info (value.type_info, i);
1044 child.type_info = member_info->type_info;
1045  
1046 g_variant_type_info_query (child.type_info, &alignment, &fixed_size);
1047  
1048 while (offset & alignment)
1049 {
1050 if (offset > value.size || value.data[offset] != '\0')
1051 return FALSE;
1052 offset++;
1053 }
1054  
1055 child.data = value.data + offset;
1056  
1057 switch (member_info->ending_type)
1058 {
1059 case G_VARIANT_MEMBER_ENDING_FIXED:
1060 end = offset + fixed_size;
1061 break;
1062  
1063 case G_VARIANT_MEMBER_ENDING_LAST:
1064 end = offset_ptr;
1065 break;
1066  
1067 case G_VARIANT_MEMBER_ENDING_OFFSET:
1068 offset_ptr -= offset_size;
1069  
1070 if (offset_ptr < offset)
1071 return FALSE;
1072  
1073 end = gvs_read_unaligned_le (value.data + offset_ptr, offset_size);
1074 break;
1075  
1076 default:
1077 g_assert_not_reached ();
1078 }
1079  
1080 if (end < offset || end > offset_ptr)
1081 return FALSE;
1082  
1083 child.size = end - offset;
1084  
1085 if (child.size == 0)
1086 child.data = NULL;
1087  
1088 if (!g_variant_serialised_is_normal (child))
1089 return FALSE;
1090  
1091 offset = end;
1092 }
1093  
1094 {
1095 gsize fixed_size;
1096 guint alignment;
1097  
1098 g_variant_type_info_query (value.type_info, &alignment, &fixed_size);
1099  
1100 if (fixed_size)
1101 {
1102 g_assert (fixed_size == value.size);
1103 g_assert (offset_ptr == value.size);
1104  
1105 if (i == 0)
1106 {
1107 if (value.data[offset++] != '\0')
1108 return FALSE;
1109 }
1110 else
1111 {
1112 while (offset & alignment)
1113 if (value.data[offset++] != '\0')
1114 return FALSE;
1115 }
1116  
1117 g_assert (offset == value.size);
1118 }
1119 }
1120  
1121 return offset_ptr == offset;
1122 }
1123  
1124 /* Variants {{{2
1125 *
1126 * Variants are stored by storing the serialised data of the child,
1127 * followed by a '\0' character, followed by the type string of the
1128 * child.
1129 *
1130 * In the case that a value is presented that contains no '\0'
1131 * character, or doesn't have a single well-formed definite type string
1132 * following that character, the variant must be taken as containing the
1133 * unit tuple: ().
1134 */
1135  
1136 static inline gsize
1137 gvs_variant_n_children (GVariantSerialised value)
1138 {
1139 return 1;
1140 }
1141  
1142 static inline GVariantSerialised
1143 gvs_variant_get_child (GVariantSerialised value,
1144 gsize index_)
1145 {
1146 GVariantSerialised child = { 0, };
1147  
1148 /* NOTE: not O(1) and impossible for it to be... */
1149 if (value.size)
1150 {
1151 /* find '\0' character */
1152 for (child.size = value.size - 1; child.size; child.size--)
1153 if (value.data[child.size] == '\0')
1154 break;
1155  
1156 /* ensure we didn't just hit the start of the string */
1157 if (value.data[child.size] == '\0')
1158 {
1159 const gchar *type_string = (gchar *) &value.data[child.size + 1];
1160 const gchar *limit = (gchar *) &value.data[value.size];
1161 const gchar *end;
1162  
1163 if (g_variant_type_string_scan (type_string, limit, &end) &&
1164 end == limit)
1165 {
1166 const GVariantType *type = (GVariantType *) type_string;
1167  
1168 if (g_variant_type_is_definite (type))
1169 {
1170 gsize fixed_size;
1171  
1172 child.type_info = g_variant_type_info_get (type);
1173  
1174 if (child.size != 0)
1175 /* only set to non-%NULL if size > 0 */
1176 child.data = value.data;
1177  
1178 g_variant_type_info_query (child.type_info,
1179 NULL, &fixed_size);
1180  
1181 if (!fixed_size || fixed_size == child.size)
1182 return child;
1183  
1184 g_variant_type_info_unref (child.type_info);
1185 }
1186 }
1187 }
1188 }
1189  
1190 child.type_info = g_variant_type_info_get (G_VARIANT_TYPE_UNIT);
1191 child.data = NULL;
1192 child.size = 1;
1193  
1194 return child;
1195 }
1196  
1197 static inline gsize
1198 gvs_variant_needed_size (GVariantTypeInfo *type_info,
1199 GVariantSerialisedFiller gvs_filler,
1200 const gpointer *children,
1201 gsize n_children)
1202 {
1203 GVariantSerialised child = { 0, };
1204 const gchar *type_string;
1205  
1206 gvs_filler (&child, children[0]);
1207 type_string = g_variant_type_info_get_type_string (child.type_info);
1208  
1209 return child.size + 1 + strlen (type_string);
1210 }
1211  
1212 static inline void
1213 gvs_variant_serialise (GVariantSerialised value,
1214 GVariantSerialisedFiller gvs_filler,
1215 const gpointer *children,
1216 gsize n_children)
1217 {
1218 GVariantSerialised child = { 0, };
1219 const gchar *type_string;
1220  
1221 child.data = value.data;
1222  
1223 gvs_filler (&child, children[0]);
1224 type_string = g_variant_type_info_get_type_string (child.type_info);
1225 value.data[child.size] = '\0';
1226 memcpy (value.data + child.size + 1, type_string, strlen (type_string));
1227 }
1228  
1229 static inline gboolean
1230 gvs_variant_is_normal (GVariantSerialised value)
1231 {
1232 GVariantSerialised child;
1233 gboolean normal;
1234  
1235 child = gvs_variant_get_child (value, 0);
1236  
1237 normal = (child.data != NULL || child.size == 0) &&
1238 g_variant_serialised_is_normal (child);
1239  
1240 g_variant_type_info_unref (child.type_info);
1241  
1242 return normal;
1243 }
1244  
1245  
1246  
1247 /* PART 2: Serialiser API {{{1
1248 *
1249 * This is the implementation of the API of the serialiser as advertised
1250 * in gvariant-serialiser.h.
1251 */
1252  
1253 /* Dispatch Utilities {{{2
1254 *
1255 * These macros allow a given function (for example,
1256 * g_variant_serialiser_serialise) to be dispatched to the appropriate
1257 * type-specific function above (fixed/variable-sized maybe,
1258 * fixed/variable-sized array, tuple or variant).
1259 */
1260 #define DISPATCH_FIXED(type_info, before, after) \
1261 { \
1262 gsize fixed_size; \
1263 \
1264 g_variant_type_info_query_element (type_info, NULL, \
1265 &fixed_size); \
1266 \
1267 if (fixed_size) \
1268 { \
1269 before ## fixed_sized ## after \
1270 } \
1271 else \
1272 { \
1273 before ## variable_sized ## after \
1274 } \
1275 }
1276  
1277 #define DISPATCH_CASES(type_info, before, after) \
1278 switch (g_variant_type_info_get_type_char (type_info)) \
1279 { \
1280 case G_VARIANT_TYPE_INFO_CHAR_MAYBE: \
1281 DISPATCH_FIXED (type_info, before, _maybe ## after) \
1282 \
1283 case G_VARIANT_TYPE_INFO_CHAR_ARRAY: \
1284 DISPATCH_FIXED (type_info, before, _array ## after) \
1285 \
1286 case G_VARIANT_TYPE_INFO_CHAR_DICT_ENTRY: \
1287 case G_VARIANT_TYPE_INFO_CHAR_TUPLE: \
1288 { \
1289 before ## tuple ## after \
1290 } \
1291 \
1292 case G_VARIANT_TYPE_INFO_CHAR_VARIANT: \
1293 { \
1294 before ## variant ## after \
1295 } \
1296 }
1297  
1298 /* Serialiser entry points {{{2
1299 *
1300 * These are the functions that are called in order for the serialiser
1301 * to do its thing.
1302 */
1303  
1304 /* < private >
1305 * g_variant_serialised_n_children:
1306 * @serialised: a #GVariantSerialised
1307 *
1308 * For serialised data that represents a container value (maybes,
1309 * tuples, arrays, variants), determine how many child items are inside
1310 * that container.
1311 *
1312 * Returns: the number of children
1313 */
1314 gsize
1315 g_variant_serialised_n_children (GVariantSerialised serialised)
1316 {
1317 g_variant_serialised_check (serialised);
1318  
1319 DISPATCH_CASES (serialised.type_info,
1320  
1321 return gvs_/**/,/**/_n_children (serialised);
1322  
1323 )
1324 g_assert_not_reached ();
1325 }
1326  
1327 /* < private >
1328 * g_variant_serialised_get_child:
1329 * @serialised: a #GVariantSerialised
1330 * @index_: the index of the child to fetch
1331 *
1332 * Extracts a child from a serialised data representing a container
1333 * value.
1334 *
1335 * It is an error to call this function with an index out of bounds.
1336 *
1337 * If the result .data == %NULL and .size > 0 then there has been an
1338 * error extracting the requested fixed-sized value. This number of
1339 * zero bytes needs to be allocated instead.
1340 *
1341 * In the case that .data == %NULL and .size == 0 then a zero-sized
1342 * item of a variable-sized type is being returned.
1343 *
1344 * .data is never non-%NULL if size is 0.
1345 *
1346 * Returns: a #GVariantSerialised for the child
1347 */
1348 GVariantSerialised
1349 g_variant_serialised_get_child (GVariantSerialised serialised,
1350 gsize index_)
1351 {
1352 GVariantSerialised child;
1353  
1354 g_variant_serialised_check (serialised);
1355  
1356 if G_LIKELY (index_ < g_variant_serialised_n_children (serialised))
1357 {
1358 DISPATCH_CASES (serialised.type_info,
1359  
1360 child = gvs_/**/,/**/_get_child (serialised, index_);
1361 g_assert (child.size || child.data == NULL);
1362 g_variant_serialised_check (child);
1363 return child;
1364  
1365 )
1366 g_assert_not_reached ();
1367 }
1368  
1369 g_error ("Attempt to access item %"G_GSIZE_FORMAT
1370 " in a container with only %"G_GSIZE_FORMAT" items",
1371 index_, g_variant_serialised_n_children (serialised));
1372 }
1373  
1374 /* < private >
1375 * g_variant_serialiser_serialise:
1376 * @serialised: a #GVariantSerialised, properly set up
1377 * @gvs_filler: the filler function
1378 * @children: an array of child items
1379 * @n_children: the size of @children
1380 *
1381 * Writes data in serialised form.
1382 *
1383 * The type_info field of @serialised must be filled in to type info for
1384 * the type that we are serialising.
1385 *
1386 * The size field of @serialised must be filled in with the value
1387 * returned by a previous call to g_variant_serialiser_needed_size().
1388 *
1389 * The data field of @serialised must be a pointer to a properly-aligned
1390 * memory region large enough to serialise into (ie: at least as big as
1391 * the size field).
1392 *
1393 * This function is only resonsible for serialising the top-level
1394 * container. @gvs_filler is called on each child of the container in
1395 * order for all of the data of that child to be filled in.
1396 */
1397 void
1398 g_variant_serialiser_serialise (GVariantSerialised serialised,
1399 GVariantSerialisedFiller gvs_filler,
1400 const gpointer *children,
1401 gsize n_children)
1402 {
1403 g_variant_serialised_check (serialised);
1404  
1405 DISPATCH_CASES (serialised.type_info,
1406  
1407 gvs_/**/,/**/_serialise (serialised, gvs_filler,
1408 children, n_children);
1409 return;
1410  
1411 )
1412 g_assert_not_reached ();
1413 }
1414  
1415 /* < private >
1416 * g_variant_serialiser_needed_size:
1417 * @type_info: the type to serialise for
1418 * @gvs_filler: the filler function
1419 * @children: an array of child items
1420 * @n_children: the size of @children
1421 *
1422 * Determines how much memory would be needed to serialise this value.
1423 *
1424 * This function is only resonsible for performing calculations for the
1425 * top-level container. @gvs_filler is called on each child of the
1426 * container in order to determine its size.
1427 */
1428 gsize
1429 g_variant_serialiser_needed_size (GVariantTypeInfo *type_info,
1430 GVariantSerialisedFiller gvs_filler,
1431 const gpointer *children,
1432 gsize n_children)
1433 {
1434 DISPATCH_CASES (type_info,
1435  
1436 return gvs_/**/,/**/_needed_size (type_info, gvs_filler,
1437 children, n_children);
1438  
1439 )
1440 g_assert_not_reached ();
1441 }
1442  
1443 /* Byteswapping {{{2 */
1444  
1445 /* < private >
1446 * g_variant_serialised_byteswap:
1447 * @value: a #GVariantSerialised
1448 *
1449 * Byte-swap serialised data. The result of this function is only
1450 * well-defined if the data is in normal form.
1451 */
1452 void
1453 g_variant_serialised_byteswap (GVariantSerialised serialised)
1454 {
1455 gsize fixed_size;
1456 guint alignment;
1457  
1458 g_variant_serialised_check (serialised);
1459  
1460 if (!serialised.data)
1461 return;
1462  
1463 /* the types we potentially need to byteswap are
1464 * exactly those with alignment requirements.
1465 */
1466 g_variant_type_info_query (serialised.type_info, &alignment, &fixed_size);
1467 if (!alignment)
1468 return;
1469  
1470 /* if fixed size and alignment are equal then we are down
1471 * to the base integer type and we should swap it. the
1472 * only exception to this is if we have a tuple with a
1473 * single item, and then swapping it will be OK anyway.
1474 */
1475 if (alignment + 1 == fixed_size)
1476 {
1477 switch (fixed_size)
1478 {
1479 case 2:
1480 {
1481 guint16 *ptr = (guint16 *) serialised.data;
1482  
1483 g_assert_cmpint (serialised.size, ==, 2);
1484 *ptr = GUINT16_SWAP_LE_BE (*ptr);
1485 }
1486 return;
1487  
1488 case 4:
1489 {
1490 guint32 *ptr = (guint32 *) serialised.data;
1491  
1492 g_assert_cmpint (serialised.size, ==, 4);
1493 *ptr = GUINT32_SWAP_LE_BE (*ptr);
1494 }
1495 return;
1496  
1497 case 8:
1498 {
1499 guint64 *ptr = (guint64 *) serialised.data;
1500  
1501 g_assert_cmpint (serialised.size, ==, 8);
1502 *ptr = GUINT64_SWAP_LE_BE (*ptr);
1503 }
1504 return;
1505  
1506 default:
1507 g_assert_not_reached ();
1508 }
1509 }
1510  
1511 /* else, we have a container that potentially contains
1512 * some children that need to be byteswapped.
1513 */
1514 else
1515 {
1516 gsize children, i;
1517  
1518 children = g_variant_serialised_n_children (serialised);
1519 for (i = 0; i < children; i++)
1520 {
1521 GVariantSerialised child;
1522  
1523 child = g_variant_serialised_get_child (serialised, i);
1524 g_variant_serialised_byteswap (child);
1525 g_variant_type_info_unref (child.type_info);
1526 }
1527 }
1528 }
1529  
1530 /* Normal form checking {{{2 */
1531  
1532 /* < private >
1533 * g_variant_serialised_is_normal:
1534 * @serialised: a #GVariantSerialised
1535 *
1536 * Determines, recursively if @serialised is in normal form. There is
1537 * precisely one normal form of serialised data for each possible value.
1538 *
1539 * It is possible that multiple byte sequences form the serialised data
1540 * for a given value if, for example, the padding bytes are filled in
1541 * with something other than zeros, but only one form is the normal
1542 * form.
1543 */
1544 gboolean
1545 g_variant_serialised_is_normal (GVariantSerialised serialised)
1546 {
1547 DISPATCH_CASES (serialised.type_info,
1548  
1549 return gvs_/**/,/**/_is_normal (serialised);
1550  
1551 )
1552  
1553 if (serialised.data == NULL)
1554 return FALSE;
1555  
1556 /* some hard-coded terminal cases */
1557 switch (g_variant_type_info_get_type_char (serialised.type_info))
1558 {
1559 case 'b': /* boolean */
1560 return serialised.data[0] < 2;
1561  
1562 case 's': /* string */
1563 return g_variant_serialiser_is_string (serialised.data,
1564 serialised.size);
1565  
1566 case 'o':
1567 return g_variant_serialiser_is_object_path (serialised.data,
1568 serialised.size);
1569  
1570 case 'g':
1571 return g_variant_serialiser_is_signature (serialised.data,
1572 serialised.size);
1573  
1574 default:
1575 /* all of the other types are fixed-sized numerical types for
1576 * which all possible values are valid (including various NaN
1577 * representations for floating point values).
1578 */
1579 return TRUE;
1580 }
1581 }
1582  
1583 /* Validity-checking functions {{{2
1584 *
1585 * Checks if strings, object paths and signature strings are valid.
1586 */
1587  
1588 /* < private >
1589 * g_variant_serialiser_is_string:
1590 * @data: a possible string
1591 * @size: the size of @data
1592 *
1593 * Ensures that @data is a valid string with a nul terminator at the end
1594 * and no nul bytes embedded.
1595 */
1596 gboolean
1597 g_variant_serialiser_is_string (gconstpointer data,
1598 gsize size)
1599 {
1600 const gchar *expected_end;
1601 const gchar *end;
1602  
1603 if (size == 0)
1604 return FALSE;
1605  
1606 expected_end = ((gchar *) data) + size - 1;
1607  
1608 if (*expected_end != '\0')
1609 return FALSE;
1610  
1611 g_utf8_validate (data, size, &end);
1612  
1613 return end == expected_end;
1614 }
1615  
1616 /* < private >
1617 * g_variant_serialiser_is_object_path:
1618 * @data: a possible D-Bus object path
1619 * @size: the size of @data
1620 *
1621 * Performs the checks for being a valid string.
1622 *
1623 * Also, ensures that @data is a valid DBus object path, as per the D-Bus
1624 * specification.
1625 */
1626 gboolean
1627 g_variant_serialiser_is_object_path (gconstpointer data,
1628 gsize size)
1629 {
1630 const gchar *string = data;
1631 gsize i;
1632  
1633 if (!g_variant_serialiser_is_string (data, size))
1634 return FALSE;
1635  
1636 /* The path must begin with an ASCII '/' (integer 47) character */
1637 if (string[0] != '/')
1638 return FALSE;
1639  
1640 for (i = 1; string[i]; i++)
1641 /* Each element must only contain the ASCII characters
1642 * "[A-Z][a-z][0-9]_"
1643 */
1644 if (g_ascii_isalnum (string[i]) || string[i] == '_')
1645 ;
1646  
1647 /* must consist of elements separated by slash characters. */
1648 else if (string[i] == '/')
1649 {
1650 /* No element may be the empty string. */
1651 /* Multiple '/' characters cannot occur in sequence. */
1652 if (string[i - 1] == '/')
1653 return FALSE;
1654 }
1655  
1656 else
1657 return FALSE;
1658  
1659 /* A trailing '/' character is not allowed unless the path is the
1660 * root path (a single '/' character).
1661 */
1662 if (i > 1 && string[i - 1] == '/')
1663 return FALSE;
1664  
1665 return TRUE;
1666 }
1667  
1668 /* < private >
1669 * g_variant_serialiser_is_signature:
1670 * @data: a possible D-Bus signature
1671 * @size: the size of @data
1672 *
1673 * Performs the checks for being a valid string.
1674 *
1675 * Also, ensures that @data is a valid D-Bus type signature, as per the
1676 * D-Bus specification.
1677 */
1678 gboolean
1679 g_variant_serialiser_is_signature (gconstpointer data,
1680 gsize size)
1681 {
1682 const gchar *string = data;
1683 gsize first_invalid;
1684  
1685 if (!g_variant_serialiser_is_string (data, size))
1686 return FALSE;
1687  
1688 /* make sure no non-definite characters appear */
1689 first_invalid = strspn (string, "ybnqiuxthdvasog(){}");
1690 if (string[first_invalid])
1691 return FALSE;
1692  
1693 /* make sure each type string is well-formed */
1694 while (*string)
1695 if (!g_variant_type_string_scan (string, NULL, &string))
1696 return FALSE;
1697  
1698 return TRUE;
1699 }
1700  
1701 /* Epilogue {{{1 */
1702 /* vim:set foldmethod=marker: */