nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* GDBus - GLib D-Bus Library
2 *
3 * Copyright (C) 2008-2010 Red Hat, Inc.
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
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 *
18 * Author: David Zeuthen <davidz@redhat.com>
19 */
20  
21 #include "config.h"
22  
23 #include <stdlib.h>
24 #include <string.h>
25  
26 #include "gdbusintrospection.h"
27  
28 #include "glibintl.h"
29  
30 /**
31 * SECTION:gdbusintrospection
32 * @title: D-Bus Introspection Data
33 * @short_description: Node and interface description data structures
34 * @include: gio/gio.h
35 *
36 * Various data structures and convenience routines to parse and
37 * generate D-Bus introspection XML. Introspection information is
38 * used when registering objects with g_dbus_connection_register_object().
39 *
40 * The format of D-Bus introspection XML is specified in the
41 * [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format)
42 */
43  
44 /* ---------------------------------------------------------------------------------------------------- */
45  
46 #define _MY_DEFINE_BOXED_TYPE(TypeName, type_name) \
47 G_DEFINE_BOXED_TYPE (TypeName, type_name, type_name##_ref, type_name##_unref)
48  
49 _MY_DEFINE_BOXED_TYPE (GDBusNodeInfo, g_dbus_node_info);
50 _MY_DEFINE_BOXED_TYPE (GDBusInterfaceInfo, g_dbus_interface_info);
51 _MY_DEFINE_BOXED_TYPE (GDBusMethodInfo, g_dbus_method_info);
52 _MY_DEFINE_BOXED_TYPE (GDBusSignalInfo, g_dbus_signal_info);
53 _MY_DEFINE_BOXED_TYPE (GDBusPropertyInfo, g_dbus_property_info);
54 _MY_DEFINE_BOXED_TYPE (GDBusArgInfo, g_dbus_arg_info);
55 _MY_DEFINE_BOXED_TYPE (GDBusAnnotationInfo, g_dbus_annotation_info);
56  
57 /* ---------------------------------------------------------------------------------------------------- */
58  
59 typedef struct
60 {
61 /* stuff we are currently collecting */
62 GPtrArray *args;
63 GPtrArray *out_args;
64 GPtrArray *methods;
65 GPtrArray *signals;
66 GPtrArray *properties;
67 GPtrArray *interfaces;
68 GPtrArray *nodes;
69 GPtrArray *annotations;
70  
71 /* A list of GPtrArray's containing annotations */
72 GSList *annotations_stack;
73  
74 /* A list of GPtrArray's containing interfaces */
75 GSList *interfaces_stack;
76  
77 /* A list of GPtrArray's containing nodes */
78 GSList *nodes_stack;
79  
80 /* Whether the direction was "in" for last parsed arg */
81 gboolean last_arg_was_in;
82  
83 /* Number of args currently being collected; used for assigning
84 * names to args without a "name" attribute
85 */
86 guint num_args;
87  
88 } ParseData;
89  
90 /* ---------------------------------------------------------------------------------------------------- */
91  
92 /**
93 * g_dbus_node_info_ref:
94 * @info: A #GDBusNodeInfo
95 *
96 * If @info is statically allocated does nothing. Otherwise increases
97 * the reference count.
98 *
99 * Returns: The same @info.
100 *
101 * Since: 2.26
102 */
103 GDBusNodeInfo *
104 g_dbus_node_info_ref (GDBusNodeInfo *info)
105 {
106 if (info->ref_count == -1)
107 return info;
108 g_atomic_int_inc (&info->ref_count);
109 return info;
110 }
111  
112 /**
113 * g_dbus_interface_info_ref:
114 * @info: A #GDBusInterfaceInfo
115 *
116 * If @info is statically allocated does nothing. Otherwise increases
117 * the reference count.
118 *
119 * Returns: The same @info.
120 *
121 * Since: 2.26
122 */
123 GDBusInterfaceInfo *
124 g_dbus_interface_info_ref (GDBusInterfaceInfo *info)
125 {
126 if (info->ref_count == -1)
127 return info;
128 g_atomic_int_inc (&info->ref_count);
129 return info;
130 }
131  
132 /**
133 * g_dbus_method_info_ref:
134 * @info: A #GDBusMethodInfo
135 *
136 * If @info is statically allocated does nothing. Otherwise increases
137 * the reference count.
138 *
139 * Returns: The same @info.
140 *
141 * Since: 2.26
142 */
143 GDBusMethodInfo *
144 g_dbus_method_info_ref (GDBusMethodInfo *info)
145 {
146 if (info->ref_count == -1)
147 return info;
148 g_atomic_int_inc (&info->ref_count);
149 return info;
150 }
151  
152 /**
153 * g_dbus_signal_info_ref:
154 * @info: A #GDBusSignalInfo
155 *
156 * If @info is statically allocated does nothing. Otherwise increases
157 * the reference count.
158 *
159 * Returns: The same @info.
160 *
161 * Since: 2.26
162 */
163 GDBusSignalInfo *
164 g_dbus_signal_info_ref (GDBusSignalInfo *info)
165 {
166 if (info->ref_count == -1)
167 return info;
168 g_atomic_int_inc (&info->ref_count);
169 return info;
170 }
171  
172 /**
173 * g_dbus_property_info_ref:
174 * @info: A #GDBusPropertyInfo
175 *
176 * If @info is statically allocated does nothing. Otherwise increases
177 * the reference count.
178 *
179 * Returns: The same @info.
180 *
181 * Since: 2.26
182 */
183 GDBusPropertyInfo *
184 g_dbus_property_info_ref (GDBusPropertyInfo *info)
185 {
186 if (info->ref_count == -1)
187 return info;
188 g_atomic_int_inc (&info->ref_count);
189 return info;
190 }
191  
192 /**
193 * g_dbus_arg_info_ref:
194 * @info: A #GDBusArgInfo
195 *
196 * If @info is statically allocated does nothing. Otherwise increases
197 * the reference count.
198 *
199 * Returns: The same @info.
200 *
201 * Since: 2.26
202 */
203 GDBusArgInfo *
204 g_dbus_arg_info_ref (GDBusArgInfo *info)
205 {
206 if (info->ref_count == -1)
207 return info;
208 g_atomic_int_inc (&info->ref_count);
209 return info;
210 }
211  
212 /**
213 * g_dbus_annotation_info_ref:
214 * @info: A #GDBusNodeInfo
215 *
216 * If @info is statically allocated does nothing. Otherwise increases
217 * the reference count.
218 *
219 * Returns: The same @info.
220 *
221 * Since: 2.26
222 */
223 GDBusAnnotationInfo *
224 g_dbus_annotation_info_ref (GDBusAnnotationInfo *info)
225 {
226 if (info->ref_count == -1)
227 return info;
228 g_atomic_int_inc (&info->ref_count);
229 return info;
230 }
231  
232 /* ---------------------------------------------------------------------------------------------------- */
233  
234 static void
235 free_null_terminated_array (gpointer array, GDestroyNotify unref_func)
236 {
237 guint n;
238 gpointer *p = array;
239 if (p == NULL)
240 return;
241 for (n = 0; p[n] != NULL; n++)
242 unref_func (p[n]);
243 g_free (p);
244 }
245  
246 /**
247 * g_dbus_annotation_info_unref:
248 * @info: A #GDBusAnnotationInfo.
249 *
250 * If @info is statically allocated, does nothing. Otherwise decreases
251 * the reference count of @info. When its reference count drops to 0,
252 * the memory used is freed.
253 *
254 * Since: 2.26
255 */
256 void
257 g_dbus_annotation_info_unref (GDBusAnnotationInfo *info)
258 {
259 if (info->ref_count == -1)
260 return;
261 if (g_atomic_int_dec_and_test (&info->ref_count))
262 {
263 g_free (info->key);
264 g_free (info->value);
265 free_null_terminated_array (info->annotations, (GDestroyNotify) g_dbus_annotation_info_unref);
266 g_free (info);
267 }
268 }
269  
270 /**
271 * g_dbus_arg_info_unref:
272 * @info: A #GDBusArgInfo.
273 *
274 * If @info is statically allocated, does nothing. Otherwise decreases
275 * the reference count of @info. When its reference count drops to 0,
276 * the memory used is freed.
277 *
278 * Since: 2.26
279 */
280 void
281 g_dbus_arg_info_unref (GDBusArgInfo *info)
282 {
283 if (info->ref_count == -1)
284 return;
285 if (g_atomic_int_dec_and_test (&info->ref_count))
286 {
287 g_free (info->name);
288 g_free (info->signature);
289 free_null_terminated_array (info->annotations, (GDestroyNotify) g_dbus_annotation_info_unref);
290 g_free (info);
291 }
292 }
293  
294 /**
295 * g_dbus_method_info_unref:
296 * @info: A #GDBusMethodInfo.
297 *
298 * If @info is statically allocated, does nothing. Otherwise decreases
299 * the reference count of @info. When its reference count drops to 0,
300 * the memory used is freed.
301 *
302 * Since: 2.26
303 */
304 void
305 g_dbus_method_info_unref (GDBusMethodInfo *info)
306 {
307 if (info->ref_count == -1)
308 return;
309 if (g_atomic_int_dec_and_test (&info->ref_count))
310 {
311 g_free (info->name);
312 free_null_terminated_array (info->in_args, (GDestroyNotify) g_dbus_arg_info_unref);
313 free_null_terminated_array (info->out_args, (GDestroyNotify) g_dbus_arg_info_unref);
314 free_null_terminated_array (info->annotations, (GDestroyNotify) g_dbus_annotation_info_unref);
315 g_free (info);
316 }
317 }
318  
319 /**
320 * g_dbus_signal_info_unref:
321 * @info: A #GDBusSignalInfo.
322 *
323 * If @info is statically allocated, does nothing. Otherwise decreases
324 * the reference count of @info. When its reference count drops to 0,
325 * the memory used is freed.
326 *
327 * Since: 2.26
328 */
329 void
330 g_dbus_signal_info_unref (GDBusSignalInfo *info)
331 {
332 if (info->ref_count == -1)
333 return;
334 if (g_atomic_int_dec_and_test (&info->ref_count))
335 {
336 g_free (info->name);
337 free_null_terminated_array (info->args, (GDestroyNotify) g_dbus_arg_info_unref);
338 free_null_terminated_array (info->annotations, (GDestroyNotify) g_dbus_annotation_info_unref);
339 g_free (info);
340 }
341 }
342  
343 /**
344 * g_dbus_property_info_unref:
345 * @info: A #GDBusPropertyInfo.
346 *
347 * If @info is statically allocated, does nothing. Otherwise decreases
348 * the reference count of @info. When its reference count drops to 0,
349 * the memory used is freed.
350 *
351 * Since: 2.26
352 */
353 void
354 g_dbus_property_info_unref (GDBusPropertyInfo *info)
355 {
356 if (info->ref_count == -1)
357 return;
358 if (g_atomic_int_dec_and_test (&info->ref_count))
359 {
360 g_free (info->name);
361 g_free (info->signature);
362 free_null_terminated_array (info->annotations, (GDestroyNotify) g_dbus_annotation_info_unref);
363 g_free (info);
364 }
365 }
366  
367 /**
368 * g_dbus_interface_info_unref:
369 * @info: A #GDBusInterfaceInfo.
370 *
371 * If @info is statically allocated, does nothing. Otherwise decreases
372 * the reference count of @info. When its reference count drops to 0,
373 * the memory used is freed.
374 *
375 * Since: 2.26
376 */
377 void
378 g_dbus_interface_info_unref (GDBusInterfaceInfo *info)
379 {
380 if (info->ref_count == -1)
381 return;
382 if (g_atomic_int_dec_and_test (&info->ref_count))
383 {
384 g_free (info->name);
385 free_null_terminated_array (info->methods, (GDestroyNotify) g_dbus_method_info_unref);
386 free_null_terminated_array (info->signals, (GDestroyNotify) g_dbus_signal_info_unref);
387 free_null_terminated_array (info->properties, (GDestroyNotify) g_dbus_property_info_unref);
388 free_null_terminated_array (info->annotations, (GDestroyNotify) g_dbus_annotation_info_unref);
389 g_free (info);
390 }
391 }
392  
393 /**
394 * g_dbus_node_info_unref:
395 * @info: A #GDBusNodeInfo.
396 *
397 * If @info is statically allocated, does nothing. Otherwise decreases
398 * the reference count of @info. When its reference count drops to 0,
399 * the memory used is freed.
400 *
401 * Since: 2.26
402 */
403 void
404 g_dbus_node_info_unref (GDBusNodeInfo *info)
405 {
406 if (info->ref_count == -1)
407 return;
408 if (g_atomic_int_dec_and_test (&info->ref_count))
409 {
410 g_free (info->path);
411 free_null_terminated_array (info->interfaces, (GDestroyNotify) g_dbus_interface_info_unref);
412 free_null_terminated_array (info->nodes, (GDestroyNotify) g_dbus_node_info_unref);
413 free_null_terminated_array (info->annotations, (GDestroyNotify) g_dbus_annotation_info_unref);
414 g_free (info);
415 }
416 }
417  
418 /* ---------------------------------------------------------------------------------------------------- */
419  
420 static void
421 g_dbus_annotation_info_set (ParseData *data,
422 GDBusAnnotationInfo *info,
423 const gchar *key,
424 const gchar *value,
425 GDBusAnnotationInfo **embedded_annotations)
426 {
427 info->ref_count = 1;
428  
429 if (key != NULL)
430 info->key = g_strdup (key);
431  
432 if (value != NULL)
433 info->value = g_strdup (value);
434  
435 if (embedded_annotations != NULL)
436 info->annotations = embedded_annotations;
437 }
438  
439 static void
440 g_dbus_arg_info_set (ParseData *data,
441 GDBusArgInfo *info,
442 const gchar *name,
443 const gchar *signature,
444 GDBusAnnotationInfo **annotations)
445 {
446 info->ref_count = 1;
447  
448 /* name may be NULL - TODO: compute name? */
449 if (name != NULL)
450 info->name = g_strdup (name);
451  
452 if (signature != NULL)
453 info->signature = g_strdup (signature);
454  
455 if (annotations != NULL)
456 info->annotations = annotations;
457 }
458  
459 static void
460 g_dbus_method_info_set (ParseData *data,
461 GDBusMethodInfo *info,
462 const gchar *name,
463 GDBusArgInfo **in_args,
464 GDBusArgInfo **out_args,
465 GDBusAnnotationInfo **annotations)
466 {
467 info->ref_count = 1;
468  
469 if (name != NULL)
470 info->name = g_strdup (name);
471  
472 if (in_args != NULL)
473 info->in_args = in_args;
474  
475 if (out_args != NULL)
476 info->out_args = out_args;
477  
478 if (annotations != NULL)
479 info->annotations = annotations;
480 }
481  
482 static void
483 g_dbus_signal_info_set (ParseData *data,
484 GDBusSignalInfo *info,
485 const gchar *name,
486 GDBusArgInfo **args,
487 GDBusAnnotationInfo **annotations)
488 {
489 info->ref_count = 1;
490  
491 if (name != NULL)
492 info->name = g_strdup (name);
493  
494 if (args != NULL)
495 info->args = args;
496  
497 if (annotations != NULL)
498 info->annotations = annotations;
499 }
500  
501 static void
502 g_dbus_property_info_set (ParseData *data,
503 GDBusPropertyInfo *info,
504 const gchar *name,
505 const gchar *signature,
506 GDBusPropertyInfoFlags flags,
507 GDBusAnnotationInfo **annotations)
508 {
509 info->ref_count = 1;
510  
511 if (name != NULL)
512 info->name = g_strdup (name);
513  
514 if (flags != G_DBUS_PROPERTY_INFO_FLAGS_NONE)
515 info->flags = flags;
516  
517 if (signature != NULL)
518 info->signature = g_strdup (signature);
519  
520 if (annotations != NULL)
521 info->annotations = annotations;
522 }
523  
524 static void
525 g_dbus_interface_info_set (ParseData *data,
526 GDBusInterfaceInfo *info,
527 const gchar *name,
528 GDBusMethodInfo **methods,
529 GDBusSignalInfo **signals,
530 GDBusPropertyInfo **properties,
531 GDBusAnnotationInfo **annotations)
532 {
533 info->ref_count = 1;
534  
535 if (name != NULL)
536 info->name = g_strdup (name);
537  
538 if (methods != NULL)
539 info->methods = methods;
540  
541 if (signals != NULL)
542 info->signals = signals;
543  
544 if (properties != NULL)
545 info->properties = properties;
546  
547 if (annotations != NULL)
548 info->annotations = annotations;
549 }
550  
551 static void
552 g_dbus_node_info_set (ParseData *data,
553 GDBusNodeInfo *info,
554 const gchar *path,
555 GDBusInterfaceInfo **interfaces,
556 GDBusNodeInfo **nodes,
557 GDBusAnnotationInfo **annotations)
558 {
559 info->ref_count = 1;
560  
561 if (path != NULL)
562 {
563 info->path = g_strdup (path);
564 /* TODO: relative / absolute path snafu */
565 }
566  
567 if (interfaces != NULL)
568 info->interfaces = interfaces;
569  
570 if (nodes != NULL)
571 info->nodes = nodes;
572  
573 if (annotations != NULL)
574 info->annotations = annotations;
575 }
576  
577 /* ---------------------------------------------------------------------------------------------------- */
578  
579 static void
580 g_dbus_annotation_info_generate_xml (GDBusAnnotationInfo *info,
581 guint indent,
582 GString *string_builder)
583 {
584 gchar *tmp;
585 guint n;
586  
587 tmp = g_markup_printf_escaped ("%*s<annotation name=\"%s\" value=\"%s\"",
588 indent, "",
589 info->key,
590 info->value);
591 g_string_append (string_builder, tmp);
592 g_free (tmp);
593  
594 if (info->annotations == NULL)
595 {
596 g_string_append (string_builder, "/>\n");
597 }
598 else
599 {
600 g_string_append (string_builder, ">\n");
601  
602 for (n = 0; info->annotations != NULL && info->annotations[n] != NULL; n++)
603 g_dbus_annotation_info_generate_xml (info->annotations[n],
604 indent + 2,
605 string_builder);
606  
607 g_string_append_printf (string_builder, "%*s</annotation>\n",
608 indent, "");
609 }
610  
611 }
612  
613 static void
614 g_dbus_arg_info_generate_xml (GDBusArgInfo *info,
615 guint indent,
616 const gchar *extra_attributes,
617 GString *string_builder)
618 {
619 guint n;
620  
621 g_string_append_printf (string_builder, "%*s<arg type=\"%s\"",
622 indent, "",
623 info->signature);
624  
625 if (info->name != NULL)
626 g_string_append_printf (string_builder, " name=\"%s\"", info->name);
627  
628 if (extra_attributes != NULL)
629 g_string_append_printf (string_builder, " %s", extra_attributes);
630  
631 if (info->annotations == NULL)
632 {
633 g_string_append (string_builder, "/>\n");
634 }
635 else
636 {
637 g_string_append (string_builder, ">\n");
638  
639 for (n = 0; info->annotations != NULL && info->annotations[n] != NULL; n++)
640 g_dbus_annotation_info_generate_xml (info->annotations[n],
641 indent + 2,
642 string_builder);
643  
644 g_string_append_printf (string_builder, "%*s</arg>\n", indent, "");
645 }
646  
647 }
648  
649 static void
650 g_dbus_method_info_generate_xml (GDBusMethodInfo *info,
651 guint indent,
652 GString *string_builder)
653 {
654 guint n;
655  
656 g_string_append_printf (string_builder, "%*s<method name=\"%s\"",
657 indent, "",
658 info->name);
659  
660 if (info->annotations == NULL && info->in_args == NULL && info->out_args == NULL)
661 {
662 g_string_append (string_builder, "/>\n");
663 }
664 else
665 {
666 g_string_append (string_builder, ">\n");
667  
668 for (n = 0; info->annotations != NULL && info->annotations[n] != NULL; n++)
669 g_dbus_annotation_info_generate_xml (info->annotations[n],
670 indent + 2,
671 string_builder);
672  
673 for (n = 0; info->in_args != NULL && info->in_args[n] != NULL; n++)
674 g_dbus_arg_info_generate_xml (info->in_args[n],
675 indent + 2,
676 "direction=\"in\"",
677 string_builder);
678  
679 for (n = 0; info->out_args != NULL && info->out_args[n] != NULL; n++)
680 g_dbus_arg_info_generate_xml (info->out_args[n],
681 indent + 2,
682 "direction=\"out\"",
683 string_builder);
684  
685 g_string_append_printf (string_builder, "%*s</method>\n", indent, "");
686 }
687 }
688  
689 static void
690 g_dbus_signal_info_generate_xml (GDBusSignalInfo *info,
691 guint indent,
692 GString *string_builder)
693 {
694 guint n;
695  
696 g_string_append_printf (string_builder, "%*s<signal name=\"%s\"",
697 indent, "",
698 info->name);
699  
700 if (info->annotations == NULL && info->args == NULL)
701 {
702 g_string_append (string_builder, "/>\n");
703 }
704 else
705 {
706 g_string_append (string_builder, ">\n");
707  
708 for (n = 0; info->annotations != NULL && info->annotations[n] != NULL; n++)
709 g_dbus_annotation_info_generate_xml (info->annotations[n],
710 indent + 2,
711 string_builder);
712  
713 for (n = 0; info->args != NULL && info->args[n] != NULL; n++)
714 g_dbus_arg_info_generate_xml (info->args[n],
715 indent + 2,
716 NULL,
717 string_builder);
718  
719 g_string_append_printf (string_builder, "%*s</signal>\n", indent, "");
720 }
721 }
722  
723 static void
724 g_dbus_property_info_generate_xml (GDBusPropertyInfo *info,
725 guint indent,
726 GString *string_builder)
727 {
728 guint n;
729 const gchar *access_string;
730  
731 if ((info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE) &&
732 (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE))
733 {
734 access_string = "readwrite";
735 }
736 else if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
737 {
738 access_string = "read";
739 }
740 else if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE)
741 {
742 access_string = "write";
743 }
744 else
745 {
746 g_assert_not_reached ();
747 }
748  
749 g_string_append_printf (string_builder, "%*s<property type=\"%s\" name=\"%s\" access=\"%s\"",
750 indent, "",
751 info->signature,
752 info->name,
753 access_string);
754  
755 if (info->annotations == NULL)
756 {
757 g_string_append (string_builder, "/>\n");
758 }
759 else
760 {
761 g_string_append (string_builder, ">\n");
762  
763 for (n = 0; info->annotations != NULL && info->annotations[n] != NULL; n++)
764 g_dbus_annotation_info_generate_xml (info->annotations[n],
765 indent + 2,
766 string_builder);
767  
768 g_string_append_printf (string_builder, "%*s</property>\n", indent, "");
769 }
770  
771 }
772  
773 /**
774 * g_dbus_interface_info_generate_xml:
775 * @info: A #GDBusNodeInfo
776 * @indent: Indentation level.
777 * @string_builder: (out): A #GString to to append XML data to.
778 *
779 * Appends an XML representation of @info (and its children) to @string_builder.
780 *
781 * This function is typically used for generating introspection XML
782 * documents at run-time for handling the
783 * `org.freedesktop.DBus.Introspectable.Introspect`
784 * method.
785 *
786 * Since: 2.26
787 */
788 void
789 g_dbus_interface_info_generate_xml (GDBusInterfaceInfo *info,
790 guint indent,
791 GString *string_builder)
792 {
793 guint n;
794  
795 g_string_append_printf (string_builder, "%*s<interface name=\"%s\">\n",
796 indent, "",
797 info->name);
798  
799 for (n = 0; info->annotations != NULL && info->annotations[n] != NULL; n++)
800 g_dbus_annotation_info_generate_xml (info->annotations[n],
801 indent + 2,
802 string_builder);
803  
804 for (n = 0; info->methods != NULL && info->methods[n] != NULL; n++)
805 g_dbus_method_info_generate_xml (info->methods[n],
806 indent + 2,
807 string_builder);
808  
809 for (n = 0; info->signals != NULL && info->signals[n] != NULL; n++)
810 g_dbus_signal_info_generate_xml (info->signals[n],
811 indent + 2,
812 string_builder);
813  
814 for (n = 0; info->properties != NULL && info->properties[n] != NULL; n++)
815 g_dbus_property_info_generate_xml (info->properties[n],
816 indent + 2,
817 string_builder);
818  
819 g_string_append_printf (string_builder, "%*s</interface>\n", indent, "");
820 }
821  
822 /**
823 * g_dbus_node_info_generate_xml:
824 * @info: A #GDBusNodeInfo.
825 * @indent: Indentation level.
826 * @string_builder: (out): A #GString to to append XML data to.
827 *
828 * Appends an XML representation of @info (and its children) to @string_builder.
829 *
830 * This function is typically used for generating introspection XML documents at run-time for
831 * handling the `org.freedesktop.DBus.Introspectable.Introspect` method.
832 *
833 * Since: 2.26
834 */
835 void
836 g_dbus_node_info_generate_xml (GDBusNodeInfo *info,
837 guint indent,
838 GString *string_builder)
839 {
840 guint n;
841  
842 g_string_append_printf (string_builder, "%*s<node", indent, "");
843 if (info->path != NULL)
844 g_string_append_printf (string_builder, " name=\"%s\"", info->path);
845  
846 if (info->interfaces == NULL && info->nodes == NULL && info->annotations == NULL)
847 {
848 g_string_append (string_builder, "/>\n");
849 }
850 else
851 {
852 g_string_append (string_builder, ">\n");
853  
854 for (n = 0; info->annotations != NULL && info->annotations[n] != NULL; n++)
855 g_dbus_annotation_info_generate_xml (info->annotations[n],
856 indent + 2,
857 string_builder);
858  
859 for (n = 0; info->interfaces != NULL && info->interfaces[n] != NULL; n++)
860 g_dbus_interface_info_generate_xml (info->interfaces[n],
861 indent + 2,
862 string_builder);
863  
864 for (n = 0; info->nodes != NULL && info->nodes[n] != NULL; n++)
865 g_dbus_node_info_generate_xml (info->nodes[n],
866 indent + 2,
867 string_builder);
868  
869 g_string_append_printf (string_builder, "%*s</node>\n", indent, "");
870 }
871 }
872  
873 /* ---------------------------------------------------------------------------------------------------- */
874  
875 static GDBusAnnotationInfo **
876 parse_data_steal_annotations (ParseData *data,
877 guint *out_num_elements)
878 {
879 GDBusAnnotationInfo **ret;
880 if (out_num_elements != NULL)
881 *out_num_elements = data->annotations->len;
882 if (data->annotations == NULL)
883 ret = NULL;
884 else
885 {
886 g_ptr_array_add (data->annotations, NULL);
887 ret = (GDBusAnnotationInfo **) g_ptr_array_free (data->annotations, FALSE);
888 }
889 data->annotations = g_ptr_array_new ();
890 return ret;
891 }
892  
893 static GDBusArgInfo **
894 parse_data_steal_args (ParseData *data,
895 guint *out_num_elements)
896 {
897 GDBusArgInfo **ret;
898 if (out_num_elements != NULL)
899 *out_num_elements = data->args->len;
900 if (data->args == NULL)
901 ret = NULL;
902 else
903 {
904 g_ptr_array_add (data->args, NULL);
905 ret = (GDBusArgInfo **) g_ptr_array_free (data->args, FALSE);
906 }
907 data->args = g_ptr_array_new ();
908 return ret;
909 }
910  
911 static GDBusArgInfo **
912 parse_data_steal_out_args (ParseData *data,
913 guint *out_num_elements)
914 {
915 GDBusArgInfo **ret;
916 if (out_num_elements != NULL)
917 *out_num_elements = data->out_args->len;
918 if (data->out_args == NULL)
919 ret = NULL;
920 else
921 {
922 g_ptr_array_add (data->out_args, NULL);
923 ret = (GDBusArgInfo **) g_ptr_array_free (data->out_args, FALSE);
924 }
925 data->out_args = g_ptr_array_new ();
926 return ret;
927 }
928  
929 static GDBusMethodInfo **
930 parse_data_steal_methods (ParseData *data,
931 guint *out_num_elements)
932 {
933 GDBusMethodInfo **ret;
934 if (out_num_elements != NULL)
935 *out_num_elements = data->methods->len;
936 if (data->methods == NULL)
937 ret = NULL;
938 else
939 {
940 g_ptr_array_add (data->methods, NULL);
941 ret = (GDBusMethodInfo **) g_ptr_array_free (data->methods, FALSE);
942 }
943 data->methods = g_ptr_array_new ();
944 return ret;
945 }
946  
947 static GDBusSignalInfo **
948 parse_data_steal_signals (ParseData *data,
949 guint *out_num_elements)
950 {
951 GDBusSignalInfo **ret;
952 if (out_num_elements != NULL)
953 *out_num_elements = data->signals->len;
954 if (data->signals == NULL)
955 ret = NULL;
956 else
957 {
958 g_ptr_array_add (data->signals, NULL);
959 ret = (GDBusSignalInfo **) g_ptr_array_free (data->signals, FALSE);
960 }
961 data->signals = g_ptr_array_new ();
962 return ret;
963 }
964  
965 static GDBusPropertyInfo **
966 parse_data_steal_properties (ParseData *data,
967 guint *out_num_elements)
968 {
969 GDBusPropertyInfo **ret;
970 if (out_num_elements != NULL)
971 *out_num_elements = data->properties->len;
972 if (data->properties == NULL)
973 ret = NULL;
974 else
975 {
976 g_ptr_array_add (data->properties, NULL);
977 ret = (GDBusPropertyInfo **) g_ptr_array_free (data->properties, FALSE);
978 }
979 data->properties = g_ptr_array_new ();
980 return ret;
981 }
982  
983 static GDBusInterfaceInfo **
984 parse_data_steal_interfaces (ParseData *data,
985 guint *out_num_elements)
986 {
987 GDBusInterfaceInfo **ret;
988 if (out_num_elements != NULL)
989 *out_num_elements = data->interfaces->len;
990 if (data->interfaces == NULL)
991 ret = NULL;
992 else
993 {
994 g_ptr_array_add (data->interfaces, NULL);
995 ret = (GDBusInterfaceInfo **) g_ptr_array_free (data->interfaces, FALSE);
996 }
997 data->interfaces = g_ptr_array_new ();
998 return ret;
999 }
1000  
1001 static GDBusNodeInfo **
1002 parse_data_steal_nodes (ParseData *data,
1003 guint *out_num_elements)
1004 {
1005 GDBusNodeInfo **ret;
1006 if (out_num_elements != NULL)
1007 *out_num_elements = data->nodes->len;
1008 if (data->nodes == NULL)
1009 ret = NULL;
1010 else
1011 {
1012 g_ptr_array_add (data->nodes, NULL);
1013 ret = (GDBusNodeInfo **) g_ptr_array_free (data->nodes, FALSE);
1014 }
1015 data->nodes = g_ptr_array_new ();
1016 return ret;
1017 }
1018  
1019 /* ---------------------------------------------------------------------------------------------------- */
1020  
1021 static void
1022 parse_data_free_annotations (ParseData *data)
1023 {
1024 if (data->annotations == NULL)
1025 return;
1026 g_ptr_array_foreach (data->annotations, (GFunc) g_dbus_annotation_info_unref, NULL);
1027 g_ptr_array_free (data->annotations, TRUE);
1028 data->annotations = NULL;
1029 }
1030  
1031 static void
1032 parse_data_free_args (ParseData *data)
1033 {
1034 if (data->args == NULL)
1035 return;
1036 g_ptr_array_foreach (data->args, (GFunc) g_dbus_arg_info_unref, NULL);
1037 g_ptr_array_free (data->args, TRUE);
1038 data->args = NULL;
1039 }
1040  
1041 static void
1042 parse_data_free_out_args (ParseData *data)
1043 {
1044 if (data->out_args == NULL)
1045 return;
1046 g_ptr_array_foreach (data->out_args, (GFunc) g_dbus_arg_info_unref, NULL);
1047 g_ptr_array_free (data->out_args, TRUE);
1048 data->out_args = NULL;
1049 }
1050  
1051 static void
1052 parse_data_free_methods (ParseData *data)
1053 {
1054 if (data->methods == NULL)
1055 return;
1056 g_ptr_array_foreach (data->methods, (GFunc) g_dbus_method_info_unref, NULL);
1057 g_ptr_array_free (data->methods, TRUE);
1058 data->methods = NULL;
1059 }
1060  
1061 static void
1062 parse_data_free_signals (ParseData *data)
1063 {
1064 if (data->signals == NULL)
1065 return;
1066 g_ptr_array_foreach (data->signals, (GFunc) g_dbus_signal_info_unref, NULL);
1067 g_ptr_array_free (data->signals, TRUE);
1068 data->signals = NULL;
1069 }
1070  
1071 static void
1072 parse_data_free_properties (ParseData *data)
1073 {
1074 if (data->properties == NULL)
1075 return;
1076 g_ptr_array_foreach (data->properties, (GFunc) g_dbus_property_info_unref, NULL);
1077 g_ptr_array_free (data->properties, TRUE);
1078 data->properties = NULL;
1079 }
1080  
1081 static void
1082 parse_data_free_interfaces (ParseData *data)
1083 {
1084 if (data->interfaces == NULL)
1085 return;
1086 g_ptr_array_foreach (data->interfaces, (GFunc) g_dbus_interface_info_unref, NULL);
1087 g_ptr_array_free (data->interfaces, TRUE);
1088 data->interfaces = NULL;
1089 }
1090  
1091 static void
1092 parse_data_free_nodes (ParseData *data)
1093 {
1094 if (data->nodes == NULL)
1095 return;
1096 g_ptr_array_foreach (data->nodes, (GFunc) g_dbus_node_info_unref, NULL);
1097 g_ptr_array_free (data->nodes, TRUE);
1098 data->nodes = NULL;
1099 }
1100  
1101 /* ---------------------------------------------------------------------------------------------------- */
1102  
1103 static GDBusAnnotationInfo *
1104 parse_data_get_annotation (ParseData *data,
1105 gboolean create_new)
1106 {
1107 if (create_new)
1108 g_ptr_array_add (data->annotations, g_new0 (GDBusAnnotationInfo, 1));
1109 return data->annotations->pdata[data->annotations->len - 1];
1110 }
1111  
1112 static GDBusArgInfo *
1113 parse_data_get_arg (ParseData *data,
1114 gboolean create_new)
1115 {
1116 if (create_new)
1117 g_ptr_array_add (data->args, g_new0 (GDBusArgInfo, 1));
1118 return data->args->pdata[data->args->len - 1];
1119 }
1120  
1121 static GDBusArgInfo *
1122 parse_data_get_out_arg (ParseData *data,
1123 gboolean create_new)
1124 {
1125 if (create_new)
1126 g_ptr_array_add (data->out_args, g_new0 (GDBusArgInfo, 1));
1127 return data->out_args->pdata[data->out_args->len - 1];
1128 }
1129  
1130 static GDBusMethodInfo *
1131 parse_data_get_method (ParseData *data,
1132 gboolean create_new)
1133 {
1134 if (create_new)
1135 g_ptr_array_add (data->methods, g_new0 (GDBusMethodInfo, 1));
1136 return data->methods->pdata[data->methods->len - 1];
1137 }
1138  
1139 static GDBusSignalInfo *
1140 parse_data_get_signal (ParseData *data,
1141 gboolean create_new)
1142 {
1143 if (create_new)
1144 g_ptr_array_add (data->signals, g_new0 (GDBusSignalInfo, 1));
1145 return data->signals->pdata[data->signals->len - 1];
1146 }
1147  
1148 static GDBusPropertyInfo *
1149 parse_data_get_property (ParseData *data,
1150 gboolean create_new)
1151 {
1152 if (create_new)
1153 g_ptr_array_add (data->properties, g_new0 (GDBusPropertyInfo, 1));
1154 return data->properties->pdata[data->properties->len - 1];
1155 }
1156  
1157 static GDBusInterfaceInfo *
1158 parse_data_get_interface (ParseData *data,
1159 gboolean create_new)
1160 {
1161 if (create_new)
1162 g_ptr_array_add (data->interfaces, g_new0 (GDBusInterfaceInfo, 1));
1163 return data->interfaces->pdata[data->interfaces->len - 1];
1164 }
1165  
1166 static GDBusNodeInfo *
1167 parse_data_get_node (ParseData *data,
1168 gboolean create_new)
1169 {
1170 if (create_new)
1171 g_ptr_array_add (data->nodes, g_new0 (GDBusNodeInfo, 1));
1172 return data->nodes->pdata[data->nodes->len - 1];
1173 }
1174  
1175 /* ---------------------------------------------------------------------------------------------------- */
1176  
1177 static ParseData *
1178 parse_data_new (void)
1179 {
1180 ParseData *data;
1181  
1182 data = g_new0 (ParseData, 1);
1183  
1184 /* initialize arrays */
1185 parse_data_steal_annotations (data, NULL);
1186 parse_data_steal_args (data, NULL);
1187 parse_data_steal_out_args (data, NULL);
1188 parse_data_steal_methods (data, NULL);
1189 parse_data_steal_signals (data, NULL);
1190 parse_data_steal_properties (data, NULL);
1191 parse_data_steal_interfaces (data, NULL);
1192 parse_data_steal_nodes (data, NULL);
1193  
1194 return data;
1195 }
1196  
1197 static void
1198 parse_data_free (ParseData *data)
1199 {
1200 GSList *l;
1201  
1202 /* free stack of annotation arrays */
1203 for (l = data->annotations_stack; l != NULL; l = l->next)
1204 {
1205 GPtrArray *annotations = l->data;
1206 g_ptr_array_foreach (annotations, (GFunc) g_dbus_annotation_info_unref, NULL);
1207 g_ptr_array_free (annotations, TRUE);
1208 }
1209 g_slist_free (data->annotations_stack);
1210  
1211 /* free stack of interface arrays */
1212 for (l = data->interfaces_stack; l != NULL; l = l->next)
1213 {
1214 GPtrArray *interfaces = l->data;
1215 g_ptr_array_foreach (interfaces, (GFunc) g_dbus_interface_info_unref, NULL);
1216 g_ptr_array_free (interfaces, TRUE);
1217 }
1218 g_slist_free (data->interfaces_stack);
1219  
1220 /* free stack of node arrays */
1221 for (l = data->nodes_stack; l != NULL; l = l->next)
1222 {
1223 GPtrArray *nodes = l->data;
1224 g_ptr_array_foreach (nodes, (GFunc) g_dbus_node_info_unref, NULL);
1225 g_ptr_array_free (nodes, TRUE);
1226 }
1227 g_slist_free (data->nodes_stack);
1228  
1229 /* free arrays (data->annotations, data->interfaces and data->nodes have been freed above) */
1230 parse_data_free_args (data);
1231 parse_data_free_out_args (data);
1232 parse_data_free_methods (data);
1233 parse_data_free_signals (data);
1234 parse_data_free_properties (data);
1235 parse_data_free_interfaces (data);
1236 parse_data_free_annotations (data);
1237 parse_data_free_nodes (data);
1238  
1239 g_free (data);
1240 }
1241  
1242 /* ---------------------------------------------------------------------------------------------------- */
1243  
1244 static void
1245 parser_start_element (GMarkupParseContext *context,
1246 const gchar *element_name,
1247 const gchar **attribute_names,
1248 const gchar **attribute_values,
1249 gpointer user_data,
1250 GError **error)
1251 {
1252 ParseData *data = user_data;
1253 GSList *stack;
1254 const gchar *name;
1255 const gchar *type;
1256 const gchar *access;
1257 const gchar *direction;
1258 const gchar *value;
1259  
1260 name = NULL;
1261 type = NULL;
1262 access = NULL;
1263 direction = NULL;
1264 value = NULL;
1265  
1266 stack = (GSList *) g_markup_parse_context_get_element_stack (context);
1267  
1268 /* ---------------------------------------------------------------------------------------------------- */
1269 if (strcmp (element_name, "node") == 0)
1270 {
1271 if (!(g_slist_length (stack) >= 1 || strcmp (stack->next->data, "node") != 0))
1272 {
1273 g_set_error_literal (error,
1274 G_MARKUP_ERROR,
1275 G_MARKUP_ERROR_INVALID_CONTENT,
1276 "<node> elements can only be top-level or embedded in other <node> elements");
1277 goto out;
1278 }
1279  
1280 if (!g_markup_collect_attributes (element_name,
1281 attribute_names,
1282 attribute_values,
1283 error,
1284 G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "name", &name,
1285 /* some hand-written introspection XML documents use this */
1286 G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "xmlns:doc", NULL,
1287 G_MARKUP_COLLECT_INVALID))
1288 goto out;
1289  
1290 g_dbus_node_info_set (data,
1291 parse_data_get_node (data, TRUE),
1292 name,
1293 NULL,
1294 NULL,
1295 NULL);
1296  
1297 /* push the currently retrieved interfaces and nodes on the stack and prepare new arrays */
1298 data->interfaces_stack = g_slist_prepend (data->interfaces_stack, data->interfaces);
1299 data->interfaces = NULL;
1300 parse_data_steal_interfaces (data, NULL);
1301  
1302 data->nodes_stack = g_slist_prepend (data->nodes_stack, data->nodes);
1303 data->nodes = NULL;
1304 parse_data_steal_nodes (data, NULL);
1305  
1306 }
1307 /* ---------------------------------------------------------------------------------------------------- */
1308 else if (strcmp (element_name, "interface") == 0)
1309 {
1310 if (g_slist_length (stack) < 2 || strcmp (stack->next->data, "node") != 0)
1311 {
1312 g_set_error_literal (error,
1313 G_MARKUP_ERROR,
1314 G_MARKUP_ERROR_INVALID_CONTENT,
1315 "<interface> elements can only be embedded in <node> elements");
1316 goto out;
1317 }
1318  
1319 if (!g_markup_collect_attributes (element_name,
1320 attribute_names,
1321 attribute_values,
1322 error,
1323 G_MARKUP_COLLECT_STRING, "name", &name,
1324 /* seen in the wild */
1325 G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "version", NULL,
1326 G_MARKUP_COLLECT_INVALID))
1327 goto out;
1328  
1329 g_dbus_interface_info_set (data,
1330 parse_data_get_interface (data, TRUE),
1331 name,
1332 NULL,
1333 NULL,
1334 NULL,
1335 NULL);
1336  
1337 }
1338 /* ---------------------------------------------------------------------------------------------------- */
1339 else if (strcmp (element_name, "method") == 0)
1340 {
1341 if (g_slist_length (stack) < 2 || strcmp (stack->next->data, "interface") != 0)
1342 {
1343 g_set_error_literal (error,
1344 G_MARKUP_ERROR,
1345 G_MARKUP_ERROR_INVALID_CONTENT,
1346 "<method> elements can only be embedded in <interface> elements");
1347 goto out;
1348 }
1349  
1350 if (!g_markup_collect_attributes (element_name,
1351 attribute_names,
1352 attribute_values,
1353 error,
1354 G_MARKUP_COLLECT_STRING, "name", &name,
1355 /* seen in the wild */
1356 G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "version", NULL,
1357 G_MARKUP_COLLECT_INVALID))
1358 goto out;
1359  
1360 g_dbus_method_info_set (data,
1361 parse_data_get_method (data, TRUE),
1362 name,
1363 NULL,
1364 NULL,
1365 NULL);
1366  
1367 data->num_args = 0;
1368  
1369 }
1370 /* ---------------------------------------------------------------------------------------------------- */
1371 else if (strcmp (element_name, "signal") == 0)
1372 {
1373 if (g_slist_length (stack) < 2 || strcmp (stack->next->data, "interface") != 0)
1374 {
1375 g_set_error_literal (error,
1376 G_MARKUP_ERROR,
1377 G_MARKUP_ERROR_INVALID_CONTENT,
1378 "<signal> elements can only be embedded in <interface> elements");
1379 goto out;
1380 }
1381  
1382 if (!g_markup_collect_attributes (element_name,
1383 attribute_names,
1384 attribute_values,
1385 error,
1386 G_MARKUP_COLLECT_STRING, "name", &name,
1387 G_MARKUP_COLLECT_INVALID))
1388 goto out;
1389  
1390 g_dbus_signal_info_set (data,
1391 parse_data_get_signal (data, TRUE),
1392 name,
1393 NULL,
1394 NULL);
1395  
1396 data->num_args = 0;
1397  
1398 }
1399 /* ---------------------------------------------------------------------------------------------------- */
1400 else if (strcmp (element_name, "property") == 0)
1401 {
1402 GDBusPropertyInfoFlags flags;
1403  
1404 if (g_slist_length (stack) < 2 || strcmp (stack->next->data, "interface") != 0)
1405 {
1406 g_set_error_literal (error,
1407 G_MARKUP_ERROR,
1408 G_MARKUP_ERROR_INVALID_CONTENT,
1409 "<property> elements can only be embedded in <interface> elements");
1410 goto out;
1411 }
1412  
1413 if (!g_markup_collect_attributes (element_name,
1414 attribute_names,
1415 attribute_values,
1416 error,
1417 G_MARKUP_COLLECT_STRING, "name", &name,
1418 G_MARKUP_COLLECT_STRING, "type", &type,
1419 G_MARKUP_COLLECT_STRING, "access", &access,
1420 G_MARKUP_COLLECT_INVALID))
1421 goto out;
1422  
1423 if (strcmp (access, "read") == 0)
1424 flags = G_DBUS_PROPERTY_INFO_FLAGS_READABLE;
1425 else if (strcmp (access, "write") == 0)
1426 flags = G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE;
1427 else if (strcmp (access, "readwrite") == 0)
1428 flags = G_DBUS_PROPERTY_INFO_FLAGS_READABLE | G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE;
1429 else
1430 {
1431 g_set_error (error,
1432 G_MARKUP_ERROR,
1433 G_MARKUP_ERROR_INVALID_CONTENT,
1434 "Unknown value '%s' of access attribute for element <property>",
1435 access);
1436 goto out;
1437 }
1438  
1439 g_dbus_property_info_set (data,
1440 parse_data_get_property (data, TRUE),
1441 name,
1442 type,
1443 flags,
1444 NULL);
1445  
1446 }
1447 /* ---------------------------------------------------------------------------------------------------- */
1448 else if (strcmp (element_name, "arg") == 0)
1449 {
1450 gboolean is_in;
1451 gchar *name_to_use;
1452  
1453 if (g_slist_length (stack) < 2 ||
1454 (strcmp (stack->next->data, "method") != 0 &&
1455 strcmp (stack->next->data, "signal") != 0))
1456 {
1457 g_set_error_literal (error,
1458 G_MARKUP_ERROR,
1459 G_MARKUP_ERROR_INVALID_CONTENT,
1460 "<arg> elements can only be embedded in <method> or <signal> elements");
1461 goto out;
1462 }
1463  
1464 if (!g_markup_collect_attributes (element_name,
1465 attribute_names,
1466 attribute_values,
1467 error,
1468 G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "name", &name,
1469 G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL, "direction", &direction,
1470 G_MARKUP_COLLECT_STRING, "type", &type,
1471 G_MARKUP_COLLECT_INVALID))
1472 goto out;
1473  
1474 if (strcmp (stack->next->data, "method") == 0)
1475 is_in = TRUE;
1476 else
1477 is_in = FALSE;
1478 if (direction != NULL)
1479 {
1480 if (strcmp (direction, "in") == 0)
1481 is_in = TRUE;
1482 else if (strcmp (direction, "out") == 0)
1483 is_in = FALSE;
1484 else
1485 {
1486 g_set_error (error,
1487 G_MARKUP_ERROR,
1488 G_MARKUP_ERROR_INVALID_CONTENT,
1489 "Unknown value '%s' of direction attribute",
1490 direction);
1491 goto out;
1492 }
1493 }
1494  
1495 if (is_in && strcmp (stack->next->data, "signal") == 0)
1496 {
1497 g_set_error_literal (error,
1498 G_MARKUP_ERROR,
1499 G_MARKUP_ERROR_INVALID_CONTENT,
1500 "Only direction 'out' is allowed for <arg> elements embedded in <signal>");
1501 goto out;
1502 }
1503  
1504 if (name == NULL)
1505 name_to_use = g_strdup_printf ("arg_%d", data->num_args);
1506 else
1507 name_to_use = g_strdup (name);
1508 data->num_args++;
1509  
1510 if (is_in)
1511 {
1512 g_dbus_arg_info_set (data,
1513 parse_data_get_arg (data, TRUE),
1514 name_to_use,
1515 type,
1516 NULL);
1517 data->last_arg_was_in = TRUE;
1518 }
1519 else
1520 {
1521 g_dbus_arg_info_set (data,
1522 parse_data_get_out_arg (data, TRUE),
1523 name_to_use,
1524 type,
1525 NULL);
1526 data->last_arg_was_in = FALSE;
1527  
1528 }
1529  
1530 g_free (name_to_use);
1531 }
1532 /* ---------------------------------------------------------------------------------------------------- */
1533 else if (strcmp (element_name, "annotation") == 0)
1534 {
1535 if (g_slist_length (stack) < 2 ||
1536 (strcmp (stack->next->data, "node") != 0 &&
1537 strcmp (stack->next->data, "interface") != 0 &&
1538 strcmp (stack->next->data, "signal") != 0 &&
1539 strcmp (stack->next->data, "method") != 0 &&
1540 strcmp (stack->next->data, "property") != 0 &&
1541 strcmp (stack->next->data, "arg") != 0 &&
1542 strcmp (stack->next->data, "annotation") != 0))
1543 {
1544 g_set_error_literal (error,
1545 G_MARKUP_ERROR,
1546 G_MARKUP_ERROR_INVALID_CONTENT,
1547 "<annotation> elements can only be embedded in <node>, <interface>, <signal>, <method>, <property>, <arg> or <annotation> elements");
1548 goto out;
1549 }
1550  
1551 if (!g_markup_collect_attributes (element_name,
1552 attribute_names,
1553 attribute_values,
1554 error,
1555 G_MARKUP_COLLECT_STRING, "name", &name,
1556 G_MARKUP_COLLECT_STRING, "value", &value,
1557 G_MARKUP_COLLECT_INVALID))
1558 goto out;
1559  
1560 g_dbus_annotation_info_set (data,
1561 parse_data_get_annotation (data, TRUE),
1562 name,
1563 value,
1564 NULL);
1565 }
1566 /* ---------------------------------------------------------------------------------------------------- */
1567 else
1568 {
1569 /* don't bail on unknown elements; just ignore them */
1570 }
1571 /* ---------------------------------------------------------------------------------------------------- */
1572  
1573 /* push the currently retrieved annotations on the stack and prepare a new one */
1574 data->annotations_stack = g_slist_prepend (data->annotations_stack, data->annotations);
1575 data->annotations = NULL;
1576 parse_data_steal_annotations (data, NULL);
1577  
1578 out:
1579 ;
1580 }
1581  
1582 /* ---------------------------------------------------------------------------------------------------- */
1583  
1584 static GDBusAnnotationInfo **
1585 steal_annotations (ParseData *data)
1586 {
1587 return parse_data_steal_annotations (data, NULL);
1588 }
1589  
1590  
1591 static void
1592 parser_end_element (GMarkupParseContext *context,
1593 const gchar *element_name,
1594 gpointer user_data,
1595 GError **error)
1596 {
1597 ParseData *data = user_data;
1598 gboolean have_popped_annotations;
1599  
1600 have_popped_annotations = FALSE;
1601  
1602 if (strcmp (element_name, "node") == 0)
1603 {
1604 guint num_nodes;
1605 guint num_interfaces;
1606 GDBusNodeInfo **nodes;
1607 GDBusInterfaceInfo **interfaces;
1608  
1609 nodes = parse_data_steal_nodes (data, &num_nodes);
1610 interfaces = parse_data_steal_interfaces (data, &num_interfaces);
1611  
1612 /* destroy the nodes, interfaces for scope we're exiting and and pop the nodes, interfaces from the
1613 * scope we're reentering
1614 */
1615 parse_data_free_interfaces (data);
1616 data->interfaces = (GPtrArray *) data->interfaces_stack->data;
1617 data->interfaces_stack = g_slist_remove (data->interfaces_stack, data->interfaces_stack->data);
1618  
1619 parse_data_free_nodes (data);
1620 data->nodes = (GPtrArray *) data->nodes_stack->data;
1621 data->nodes_stack = g_slist_remove (data->nodes_stack, data->nodes_stack->data);
1622  
1623 g_dbus_node_info_set (data,
1624 parse_data_get_node (data, FALSE),
1625 NULL,
1626 interfaces,
1627 nodes,
1628 steal_annotations (data));
1629  
1630 }
1631 else if (strcmp (element_name, "interface") == 0)
1632 {
1633 guint num_methods;
1634 guint num_signals;
1635 guint num_properties;
1636 GDBusMethodInfo **methods;
1637 GDBusSignalInfo **signals;
1638 GDBusPropertyInfo **properties;
1639  
1640 methods = parse_data_steal_methods (data, &num_methods);
1641 signals = parse_data_steal_signals (data, &num_signals);
1642 properties = parse_data_steal_properties (data, &num_properties);
1643  
1644 g_dbus_interface_info_set (data,
1645 parse_data_get_interface (data, FALSE),
1646 NULL,
1647 methods,
1648 signals,
1649 properties,
1650 steal_annotations (data));
1651  
1652 }
1653 else if (strcmp (element_name, "method") == 0)
1654 {
1655 guint in_num_args;
1656 guint out_num_args;
1657 GDBusArgInfo **in_args;
1658 GDBusArgInfo **out_args;
1659  
1660 in_args = parse_data_steal_args (data, &in_num_args);
1661 out_args = parse_data_steal_out_args (data, &out_num_args);
1662  
1663 g_dbus_method_info_set (data,
1664 parse_data_get_method (data, FALSE),
1665 NULL,
1666 in_args,
1667 out_args,
1668 steal_annotations (data));
1669 }
1670 else if (strcmp (element_name, "signal") == 0)
1671 {
1672 guint num_args;
1673 GDBusArgInfo **args;
1674  
1675 args = parse_data_steal_out_args (data, &num_args);
1676  
1677 g_dbus_signal_info_set (data,
1678 parse_data_get_signal (data, FALSE),
1679 NULL,
1680 args,
1681 steal_annotations (data));
1682 }
1683 else if (strcmp (element_name, "property") == 0)
1684 {
1685 g_dbus_property_info_set (data,
1686 parse_data_get_property (data, FALSE),
1687 NULL,
1688 NULL,
1689 G_DBUS_PROPERTY_INFO_FLAGS_NONE,
1690 steal_annotations (data));
1691 }
1692 else if (strcmp (element_name, "arg") == 0)
1693 {
1694 g_dbus_arg_info_set (data,
1695 data->last_arg_was_in ? parse_data_get_arg (data, FALSE) : parse_data_get_out_arg (data, FALSE),
1696 NULL,
1697 NULL,
1698 steal_annotations (data));
1699 }
1700 else if (strcmp (element_name, "annotation") == 0)
1701 {
1702 GDBusAnnotationInfo **embedded_annotations;
1703  
1704 embedded_annotations = steal_annotations (data);
1705  
1706 /* destroy the annotations for scope we're exiting and and pop the annotations from the scope we're reentering */
1707 parse_data_free_annotations (data);
1708 data->annotations = (GPtrArray *) data->annotations_stack->data;
1709 data->annotations_stack = g_slist_remove (data->annotations_stack, data->annotations_stack->data);
1710  
1711 have_popped_annotations = TRUE;
1712  
1713 g_dbus_annotation_info_set (data,
1714 parse_data_get_annotation (data, FALSE),
1715 NULL,
1716 NULL,
1717 embedded_annotations);
1718 }
1719 else
1720 {
1721 /* don't bail on unknown elements; just ignore them */
1722 }
1723  
1724 if (!have_popped_annotations)
1725 {
1726 /* destroy the annotations for scope we're exiting and and pop the annotations from the scope we're reentering */
1727 parse_data_free_annotations (data);
1728 data->annotations = (GPtrArray *) data->annotations_stack->data;
1729 data->annotations_stack = g_slist_remove (data->annotations_stack, data->annotations_stack->data);
1730 }
1731 }
1732  
1733 /* ---------------------------------------------------------------------------------------------------- */
1734  
1735 static void
1736 parser_error (GMarkupParseContext *context,
1737 GError *error,
1738 gpointer user_data)
1739 {
1740 gint line_number;
1741 gint char_number;
1742  
1743 g_markup_parse_context_get_position (context, &line_number, &char_number);
1744  
1745 g_prefix_error (&error, "%d:%d: ",
1746 line_number,
1747 char_number);
1748 }
1749  
1750 /* ---------------------------------------------------------------------------------------------------- */
1751  
1752 /**
1753 * g_dbus_node_info_new_for_xml:
1754 * @xml_data: Valid D-Bus introspection XML.
1755 * @error: Return location for error.
1756 *
1757 * Parses @xml_data and returns a #GDBusNodeInfo representing the data.
1758 *
1759 * The introspection XML must contain exactly one top-level
1760 * <node> element.
1761 *
1762 * Note that this routine is using a
1763 * [GMarkup][glib-Simple-XML-Subset-Parser.description]-based
1764 * parser that only accepts a subset of valid XML documents.
1765 *
1766 * Returns: A #GDBusNodeInfo structure or %NULL if @error is set. Free
1767 * with g_dbus_node_info_unref().
1768 *
1769 * Since: 2.26
1770 */
1771 GDBusNodeInfo *
1772 g_dbus_node_info_new_for_xml (const gchar *xml_data,
1773 GError **error)
1774 {
1775 GDBusNodeInfo *ret;
1776 GMarkupParseContext *context;
1777 GMarkupParser *parser;
1778 guint num_nodes;
1779 ParseData *data;
1780 GDBusNodeInfo **ughret;
1781  
1782 ret = NULL;
1783 parser = NULL;
1784 context = NULL;
1785  
1786 parser = g_new0 (GMarkupParser, 1);
1787 parser->start_element = parser_start_element;
1788 parser->end_element = parser_end_element;
1789 parser->error = parser_error;
1790  
1791 data = parse_data_new ();
1792 context = g_markup_parse_context_new (parser,
1793 G_MARKUP_IGNORE_QUALIFIED,
1794 data,
1795 (GDestroyNotify) parse_data_free);
1796  
1797 if (!g_markup_parse_context_parse (context,
1798 xml_data,
1799 strlen (xml_data),
1800 error))
1801 goto out;
1802  
1803 if (!g_markup_parse_context_end_parse (context, error))
1804 goto out;
1805  
1806 ughret = parse_data_steal_nodes (data, &num_nodes);
1807  
1808 if (num_nodes != 1)
1809 {
1810 guint n;
1811  
1812 g_set_error (error,
1813 G_MARKUP_ERROR,
1814 G_MARKUP_ERROR_INVALID_CONTENT,
1815 "Expected a single node in introspection XML, found %d",
1816 num_nodes);
1817  
1818 /* clean up */
1819 for (n = 0; n < num_nodes; n++)
1820 {
1821 g_dbus_node_info_unref (ughret[n]);
1822 ughret[n] = NULL;
1823 }
1824 }
1825  
1826 ret = ughret[0];
1827 g_free (ughret);
1828  
1829 out:
1830 g_free (parser);
1831 if (context != NULL)
1832 g_markup_parse_context_free (context);
1833  
1834 return ret;
1835 }
1836  
1837 /* ---------------------------------------------------------------------------------------------------- */
1838  
1839 /**
1840 * g_dbus_annotation_info_lookup:
1841 * @annotations: (array zero-terminated=1) (allow-none): A %NULL-terminated array of annotations or %NULL.
1842 * @name: The name of the annotation to look up.
1843 *
1844 * Looks up the value of an annotation.
1845 *
1846 * The cost of this function is O(n) in number of annotations.
1847 *
1848 * Returns: The value or %NULL if not found. Do not free, it is owned by @annotations.
1849 *
1850 * Since: 2.26
1851 */
1852 const gchar *
1853 g_dbus_annotation_info_lookup (GDBusAnnotationInfo **annotations,
1854 const gchar *name)
1855 {
1856 guint n;
1857 const gchar *ret;
1858  
1859 ret = NULL;
1860 for (n = 0; annotations != NULL && annotations[n] != NULL; n++)
1861 {
1862 if (g_strcmp0 (annotations[n]->key, name) == 0)
1863 {
1864 ret = annotations[n]->value;
1865 goto out;
1866 }
1867 }
1868  
1869 out:
1870 return ret;
1871 }
1872  
1873 /* ---------------------------------------------------------------------------------------------------- */
1874  
1875 G_LOCK_DEFINE_STATIC (info_cache_lock);
1876  
1877 typedef struct
1878 {
1879 gint use_count;
1880  
1881 /* gchar* -> GDBusMethodInfo* */
1882 GHashTable *method_name_to_data;
1883  
1884 /* gchar* -> GDBusMethodInfo* */
1885 GHashTable *signal_name_to_data;
1886  
1887 /* gchar* -> GDBusMethodInfo* */
1888 GHashTable *property_name_to_data;
1889 } InfoCacheEntry;
1890  
1891 static void
1892 info_cache_free (InfoCacheEntry *cache)
1893 {
1894 g_assert (cache->use_count == 0);
1895 g_hash_table_unref (cache->method_name_to_data);
1896 g_hash_table_unref (cache->signal_name_to_data);
1897 g_hash_table_unref (cache->property_name_to_data);
1898 g_slice_free (InfoCacheEntry, cache);
1899 }
1900  
1901 /* maps from GDBusInterfaceInfo* to InfoCacheEntry* */
1902 static GHashTable *info_cache = NULL;
1903  
1904 /* ---------------------------------------------------------------------------------------------------- */
1905  
1906 /**
1907 * g_dbus_interface_info_lookup_method:
1908 * @info: A #GDBusInterfaceInfo.
1909 * @name: A D-Bus method name (typically in CamelCase)
1910 *
1911 * Looks up information about a method.
1912 *
1913 * The cost of this function is O(n) in number of methods unless
1914 * g_dbus_interface_info_cache_build() has been used on @info.
1915 *
1916 * Returns: (transfer none): A #GDBusMethodInfo or %NULL if not found. Do not free, it is owned by @info.
1917 *
1918 * Since: 2.26
1919 */
1920 GDBusMethodInfo *
1921 g_dbus_interface_info_lookup_method (GDBusInterfaceInfo *info,
1922 const gchar *name)
1923 {
1924 guint n;
1925 GDBusMethodInfo *result;
1926  
1927 G_LOCK (info_cache_lock);
1928 if (G_LIKELY (info_cache != NULL))
1929 {
1930 InfoCacheEntry *cache;
1931 cache = g_hash_table_lookup (info_cache, info);
1932 if (G_LIKELY (cache != NULL))
1933 {
1934 result = g_hash_table_lookup (cache->method_name_to_data, name);
1935 G_UNLOCK (info_cache_lock);
1936 goto out;
1937 }
1938 }
1939 G_UNLOCK (info_cache_lock);
1940  
1941 for (n = 0; info->methods != NULL && info->methods[n] != NULL; n++)
1942 {
1943 GDBusMethodInfo *i = info->methods[n];
1944  
1945 if (g_strcmp0 (i->name, name) == 0)
1946 {
1947 result = i;
1948 goto out;
1949 }
1950 }
1951  
1952 result = NULL;
1953  
1954 out:
1955 return result;
1956 }
1957  
1958 /* ---------------------------------------------------------------------------------------------------- */
1959  
1960 /**
1961 * g_dbus_interface_info_lookup_signal:
1962 * @info: A #GDBusInterfaceInfo.
1963 * @name: A D-Bus signal name (typically in CamelCase)
1964 *
1965 * Looks up information about a signal.
1966 *
1967 * The cost of this function is O(n) in number of signals unless
1968 * g_dbus_interface_info_cache_build() has been used on @info.
1969 *
1970 * Returns: (transfer none): A #GDBusSignalInfo or %NULL if not found. Do not free, it is owned by @info.
1971 *
1972 * Since: 2.26
1973 */
1974 GDBusSignalInfo *
1975 g_dbus_interface_info_lookup_signal (GDBusInterfaceInfo *info,
1976 const gchar *name)
1977 {
1978 guint n;
1979 GDBusSignalInfo *result;
1980  
1981 G_LOCK (info_cache_lock);
1982 if (G_LIKELY (info_cache != NULL))
1983 {
1984 InfoCacheEntry *cache;
1985 cache = g_hash_table_lookup (info_cache, info);
1986 if (G_LIKELY (cache != NULL))
1987 {
1988 result = g_hash_table_lookup (cache->signal_name_to_data, name);
1989 G_UNLOCK (info_cache_lock);
1990 goto out;
1991 }
1992 }
1993 G_UNLOCK (info_cache_lock);
1994  
1995 for (n = 0; info->signals != NULL && info->signals[n] != NULL; n++)
1996 {
1997 GDBusSignalInfo *i = info->signals[n];
1998  
1999 if (g_strcmp0 (i->name, name) == 0)
2000 {
2001 result = i;
2002 goto out;
2003 }
2004 }
2005  
2006 result = NULL;
2007  
2008 out:
2009 return result;
2010 }
2011  
2012 /* ---------------------------------------------------------------------------------------------------- */
2013  
2014 /**
2015 * g_dbus_interface_info_lookup_property:
2016 * @info: A #GDBusInterfaceInfo.
2017 * @name: A D-Bus property name (typically in CamelCase).
2018 *
2019 * Looks up information about a property.
2020 *
2021 * The cost of this function is O(n) in number of properties unless
2022 * g_dbus_interface_info_cache_build() has been used on @info.
2023 *
2024 * Returns: (transfer none): A #GDBusPropertyInfo or %NULL if not found. Do not free, it is owned by @info.
2025 *
2026 * Since: 2.26
2027 */
2028 GDBusPropertyInfo *
2029 g_dbus_interface_info_lookup_property (GDBusInterfaceInfo *info,
2030 const gchar *name)
2031 {
2032 guint n;
2033 GDBusPropertyInfo *result;
2034  
2035 G_LOCK (info_cache_lock);
2036 if (G_LIKELY (info_cache != NULL))
2037 {
2038 InfoCacheEntry *cache;
2039 cache = g_hash_table_lookup (info_cache, info);
2040 if (G_LIKELY (cache != NULL))
2041 {
2042 result = g_hash_table_lookup (cache->property_name_to_data, name);
2043 G_UNLOCK (info_cache_lock);
2044 goto out;
2045 }
2046 }
2047 G_UNLOCK (info_cache_lock);
2048  
2049 for (n = 0; info->properties != NULL && info->properties[n] != NULL; n++)
2050 {
2051 GDBusPropertyInfo *i = info->properties[n];
2052  
2053 if (g_strcmp0 (i->name, name) == 0)
2054 {
2055 result = i;
2056 goto out;
2057 }
2058 }
2059  
2060 result = NULL;
2061  
2062 out:
2063 return result;
2064 }
2065  
2066 /* ---------------------------------------------------------------------------------------------------- */
2067  
2068 /**
2069 * g_dbus_interface_info_cache_build:
2070 * @info: A #GDBusInterfaceInfo.
2071 *
2072 * Builds a lookup-cache to speed up
2073 * g_dbus_interface_info_lookup_method(),
2074 * g_dbus_interface_info_lookup_signal() and
2075 * g_dbus_interface_info_lookup_property().
2076 *
2077 * If this has already been called with @info, the existing cache is
2078 * used and its use count is increased.
2079 *
2080 * Note that @info cannot be modified until
2081 * g_dbus_interface_info_cache_release() is called.
2082 *
2083 * Since: 2.30
2084 */
2085 void
2086 g_dbus_interface_info_cache_build (GDBusInterfaceInfo *info)
2087 {
2088 InfoCacheEntry *cache;
2089 guint n;
2090  
2091 G_LOCK (info_cache_lock);
2092 if (info_cache == NULL)
2093 info_cache = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) info_cache_free);
2094 cache = g_hash_table_lookup (info_cache, info);
2095 if (cache != NULL)
2096 {
2097 cache->use_count += 1;
2098 goto out;
2099 }
2100 cache = g_slice_new0 (InfoCacheEntry);
2101 cache->use_count = 1;
2102 cache->method_name_to_data = g_hash_table_new (g_str_hash, g_str_equal);
2103 cache->signal_name_to_data = g_hash_table_new (g_str_hash, g_str_equal);
2104 cache->property_name_to_data = g_hash_table_new (g_str_hash, g_str_equal);
2105 for (n = 0; info->methods != NULL && info->methods[n] != NULL; n++)
2106 g_hash_table_insert (cache->method_name_to_data, info->methods[n]->name, info->methods[n]);
2107 for (n = 0; info->signals != NULL && info->signals[n] != NULL; n++)
2108 g_hash_table_insert (cache->signal_name_to_data, info->signals[n]->name, info->signals[n]);
2109 for (n = 0; info->properties != NULL && info->properties[n] != NULL; n++)
2110 g_hash_table_insert (cache->property_name_to_data, info->properties[n]->name, info->properties[n]);
2111 g_hash_table_insert (info_cache, info, cache);
2112 out:
2113 G_UNLOCK (info_cache_lock);
2114 }
2115  
2116 /**
2117 * g_dbus_interface_info_cache_release:
2118 * @info: A GDBusInterfaceInfo
2119 *
2120 * Decrements the usage count for the cache for @info built by
2121 * g_dbus_interface_info_cache_build() (if any) and frees the
2122 * resources used by the cache if the usage count drops to zero.
2123 *
2124 * Since: 2.30
2125 */
2126 void
2127 g_dbus_interface_info_cache_release (GDBusInterfaceInfo *info)
2128 {
2129 InfoCacheEntry *cache;
2130  
2131 G_LOCK (info_cache_lock);
2132 if (G_UNLIKELY (info_cache == NULL))
2133 {
2134 g_warning ("%s called for interface %s but there is no cache", info->name, G_STRFUNC);
2135 goto out;
2136 }
2137  
2138 cache = g_hash_table_lookup (info_cache, info);
2139 if (G_UNLIKELY (cache == NULL))
2140 {
2141 g_warning ("%s called for interface %s but there is no cache entry", info->name, G_STRFUNC);
2142 goto out;
2143 }
2144 cache->use_count -= 1;
2145 if (cache->use_count == 0)
2146 {
2147 g_hash_table_remove (info_cache, info);
2148 /* could nuke info_cache itself if empty */
2149 }
2150 out:
2151 G_UNLOCK (info_cache_lock);
2152 }
2153  
2154  
2155 /* ---------------------------------------------------------------------------------------------------- */
2156  
2157 /**
2158 * g_dbus_node_info_lookup_interface:
2159 * @info: A #GDBusNodeInfo.
2160 * @name: A D-Bus interface name.
2161 *
2162 * Looks up information about an interface.
2163 *
2164 * The cost of this function is O(n) in number of interfaces.
2165 *
2166 * Returns: (transfer none): A #GDBusInterfaceInfo or %NULL if not found. Do not free, it is owned by @info.
2167 *
2168 * Since: 2.26
2169 */
2170 GDBusInterfaceInfo *
2171 g_dbus_node_info_lookup_interface (GDBusNodeInfo *info,
2172 const gchar *name)
2173 {
2174 guint n;
2175 GDBusInterfaceInfo *result;
2176  
2177 for (n = 0; info->interfaces != NULL && info->interfaces[n] != NULL; n++)
2178 {
2179 GDBusInterfaceInfo *i = info->interfaces[n];
2180  
2181 if (g_strcmp0 (i->name, name) == 0)
2182 {
2183 result = i;
2184 goto out;
2185 }
2186 }
2187  
2188 result = NULL;
2189  
2190 out:
2191 return result;
2192 }