2004-05-21 Olivier Andrieu <oliv__a@users.sourceforge.net>
[platform/upstream/dbus.git] / dbus / dbus-object-tree.c
1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* dbus-object-tree.c  DBusObjectTree (internals of DBusConnection)
3  *
4  * Copyright (C) 2003  Red Hat Inc.
5  *
6  * Licensed under the Academic Free License version 2.0
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  *
22  */
23 #include "dbus-object-tree.h"
24 #include "dbus-connection-internal.h"
25 #include "dbus-internals.h"
26 #include "dbus-hash.h"
27 #include "dbus-protocol.h"
28 #include "dbus-string.h"
29 #include <string.h>
30 #include <stdlib.h>
31
32 /**
33  * @defgroup DBusObjectTree A hierarchy of objects with container-contained relationship
34  * @ingroup  DBusInternals
35  * @brief DBusObjectTree is used by DBusConnection to track the object tree
36  *
37  * Types and functions related to DBusObjectTree. These
38  * are all library-internal.
39  *
40  * @{
41  */
42
43 /** Subnode of the object hierarchy */
44 typedef struct DBusObjectSubtree DBusObjectSubtree;
45
46 static DBusObjectSubtree* _dbus_object_subtree_new   (const char                  *name,
47                                                       const DBusObjectPathVTable  *vtable,
48                                                       void                        *user_data);
49 static DBusObjectSubtree* _dbus_object_subtree_ref   (DBusObjectSubtree           *subtree);
50 static void               _dbus_object_subtree_unref (DBusObjectSubtree           *subtree);
51
52 /**
53  * Internals of DBusObjectTree
54  */
55 struct DBusObjectTree
56 {
57   int                 refcount;   /**< Reference count */
58   DBusConnection     *connection; /**< Connection this tree belongs to */
59
60   DBusObjectSubtree  *root;       /**< Root of the tree ("/" node) */
61 };
62
63 /**
64  * Struct representing a single registered subtree handler, or node
65  * that's a parent of a registered subtree handler. If
66  * message_function != NULL there's actually a handler at this node.
67  */
68 struct DBusObjectSubtree
69 {
70   DBusAtomic                         refcount;            /**< Reference count */
71   DBusObjectSubtree                 *parent;              /**< Parent node */
72   DBusObjectPathUnregisterFunction   unregister_function; /**< Function to call on unregister */
73   DBusObjectPathMessageFunction      message_function;    /**< Function to handle messages */
74   void                              *user_data;           /**< Data for functions */
75   DBusObjectSubtree                **subtrees;            /**< Child nodes */
76   int                                n_subtrees;          /**< Number of child nodes */
77   unsigned int                       subtrees_sorted : 1; /**< Whether children are sorted */
78   unsigned int                       invoke_as_fallback : 1; /**< Whether to invoke message_function when child nodes don't handle the message */
79   char                               name[1]; /**< Allocated as large as necessary */
80 };
81
82 /**
83  * Creates a new object tree, representing a mapping from paths
84  * to handler vtables.
85  *
86  * @param connection the connection this tree belongs to
87  * @returns the new tree or #NULL if no memory
88  */
89 DBusObjectTree*
90 _dbus_object_tree_new (DBusConnection *connection)
91 {
92   DBusObjectTree *tree;
93
94   /* the connection passed in here isn't fully constructed,
95    * so don't do anything more than store a pointer to
96    * it
97    */
98
99   tree = dbus_new0 (DBusObjectTree, 1);
100   if (tree == NULL)
101     goto oom;
102
103   tree->refcount = 1;
104   tree->connection = connection;
105   tree->root = _dbus_object_subtree_new ("/", NULL, NULL);
106   if (tree->root == NULL)
107     goto oom;
108   tree->root->invoke_as_fallback = TRUE;
109   
110   return tree;
111
112  oom:
113   if (tree)
114     {
115       dbus_free (tree);
116     }
117
118   return NULL;
119 }
120
121 /**
122  * Increment the reference count
123  * @param tree the object tree
124  * @returns the object tree
125  */
126 DBusObjectTree *
127 _dbus_object_tree_ref (DBusObjectTree *tree)
128 {
129   _dbus_assert (tree->refcount > 0);
130
131   tree->refcount += 1;
132
133   return tree;
134 }
135
136 /**
137  * Decrement the reference count
138  * @param tree the object tree
139  */
140 void
141 _dbus_object_tree_unref (DBusObjectTree *tree)
142 {
143   _dbus_assert (tree->refcount > 0);
144
145   tree->refcount -= 1;
146
147   if (tree->refcount == 0)
148     {
149       _dbus_object_tree_free_all_unlocked (tree);
150
151       dbus_free (tree);
152     }
153 }
154
155 static int
156 subtree_cmp (DBusObjectSubtree *subtree_a,
157              DBusObjectSubtree *subtree_b)
158 {
159   return strcmp (subtree_a->name, subtree_b->name);
160 }
161
162 static int
163 subtree_qsort_cmp (const void *a,
164                    const void *b)
165 {
166   DBusObjectSubtree **subtree_a_p = (void*) a;
167   DBusObjectSubtree **subtree_b_p = (void*) b;
168
169   return subtree_cmp (*subtree_a_p, *subtree_b_p);
170 }
171
172 static void
173 ensure_sorted (DBusObjectSubtree *subtree)
174 {
175   if (subtree->subtrees && !subtree->subtrees_sorted)
176     {
177       qsort (subtree->subtrees,
178              subtree->n_subtrees,
179              sizeof (DBusObjectSubtree*),
180              subtree_qsort_cmp);
181       subtree->subtrees_sorted = TRUE;
182     }
183 }
184
185 /** Set to 1 to get a bunch of debug spew about finding the
186  * subtree nodes
187  */
188 #define VERBOSE_FIND 0
189
190 static DBusObjectSubtree*
191 find_subtree_recurse (DBusObjectSubtree  *subtree,
192                       const char        **path,
193                       dbus_bool_t         return_deepest_match,
194                       dbus_bool_t         create_if_not_found,
195                       int                *index_in_parent)
196 {
197   int i;
198
199   _dbus_assert (!(return_deepest_match && create_if_not_found));
200
201   if (path[0] == NULL)
202     {
203 #if VERBOSE_FIND
204       _dbus_verbose ("  path exhausted, returning %s\n",
205                      subtree->name);
206 #endif
207       return subtree;
208     }
209
210 #if VERBOSE_FIND
211   _dbus_verbose ("  searching children of %s for %s\n",
212                  subtree->name, path[0]);
213 #endif
214   
215   ensure_sorted (subtree);
216
217   /* FIXME we should do a binary search here instead
218    * of O(n)
219    */
220
221   i = 0;
222   while (i < subtree->n_subtrees)
223     {
224       int v;
225
226       v = strcmp (path[0], subtree->subtrees[i]->name);
227
228 #if VERBOSE_FIND
229       _dbus_verbose ("  %s cmp %s = %d\n",
230                      path[0], subtree->subtrees[i]->name,
231                      v);
232 #endif
233       
234       if (v == 0)
235         {
236           if (index_in_parent)
237             {
238 #if VERBOSE_FIND
239               _dbus_verbose ("  storing parent index %d\n", i);
240 #endif
241               *index_in_parent = i;
242             }
243
244           if (return_deepest_match)
245             {
246               DBusObjectSubtree *next;
247
248               next = find_subtree_recurse (subtree->subtrees[i],
249                                            &path[1], return_deepest_match,
250                                            create_if_not_found, index_in_parent);
251               if (next == NULL &&
252                   subtree->invoke_as_fallback)
253                 {
254 #if VERBOSE_FIND
255                   _dbus_verbose ("  no deeper match found, returning %s\n",
256                                  subtree->name);
257 #endif
258                   return subtree;
259                 }
260               else
261                 return next;
262             }
263           else
264             return find_subtree_recurse (subtree->subtrees[i],
265                                          &path[1], return_deepest_match,
266                                          create_if_not_found, index_in_parent);
267         }
268       else if (v < 0)
269         {
270           goto not_found;
271         }
272
273       ++i;
274     }
275
276  not_found:
277 #if VERBOSE_FIND
278   _dbus_verbose ("  no match found, current tree %s, create_if_not_found = %d\n",
279                  subtree->name, create_if_not_found);
280 #endif
281   
282   if (create_if_not_found)
283     {
284       DBusObjectSubtree* child;
285       DBusObjectSubtree **new_subtrees;
286       int new_n_subtrees;
287
288 #if VERBOSE_FIND
289       _dbus_verbose ("  creating subtree %s\n",
290                      path[0]);
291 #endif
292       
293       child = _dbus_object_subtree_new (path[0],
294                                         NULL, NULL);
295       if (child == NULL)
296         return NULL;
297
298       /* FIXME we should do the "double alloc each time" standard thing */
299       new_n_subtrees = subtree->n_subtrees + 1;
300       new_subtrees = dbus_realloc (subtree->subtrees,
301                                    new_n_subtrees * sizeof (DBusObjectSubtree*));
302       if (new_subtrees == NULL)
303         {
304           child->unregister_function = NULL;
305           child->message_function = NULL;
306           _dbus_object_subtree_unref (child);
307           return FALSE;
308         }
309
310       new_subtrees[subtree->n_subtrees] = child;
311       if (index_in_parent)
312         *index_in_parent = subtree->n_subtrees;
313       subtree->subtrees_sorted = FALSE;
314       subtree->n_subtrees = new_n_subtrees;
315       subtree->subtrees = new_subtrees;
316
317       child->parent = subtree;
318
319       return find_subtree_recurse (child,
320                                    &path[1], return_deepest_match,
321                                    create_if_not_found, index_in_parent);
322     }
323   else
324     return (return_deepest_match && subtree->invoke_as_fallback) ? subtree : NULL;
325 }
326
327 static DBusObjectSubtree*
328 find_subtree (DBusObjectTree *tree,
329               const char    **path,
330               int            *index_in_parent)
331 {
332   DBusObjectSubtree *subtree;
333
334 #if VERBOSE_FIND
335   _dbus_verbose ("Looking for exact registered subtree\n");
336 #endif
337   
338   subtree = find_subtree_recurse (tree->root, path, FALSE, FALSE, index_in_parent);
339
340   if (subtree && subtree->message_function == NULL)
341     return NULL;
342   else
343     return subtree;
344 }
345
346 static DBusObjectSubtree*
347 lookup_subtree (DBusObjectTree *tree,
348               const char    **path)
349 {
350 #if VERBOSE_FIND
351   _dbus_verbose ("Looking for subtree\n");
352 #endif
353   return find_subtree_recurse (tree->root, path, FALSE, FALSE, NULL);
354 }
355
356 static DBusObjectSubtree*
357 find_handler (DBusObjectTree *tree,
358               const char    **path)
359 {
360 #if VERBOSE_FIND
361   _dbus_verbose ("Looking for deepest handler\n");
362 #endif
363   return find_subtree_recurse (tree->root, path, TRUE, FALSE, NULL);
364 }
365
366 static DBusObjectSubtree*
367 ensure_subtree (DBusObjectTree *tree,
368                 const char    **path)
369 {
370 #if VERBOSE_FIND
371   _dbus_verbose ("Ensuring subtree\n");
372 #endif
373   return find_subtree_recurse (tree->root, path, FALSE, TRUE, NULL);
374 }
375
376 /**
377  * Registers a new subtree in the global object tree.
378  *
379  * @param tree the global object tree
380  * @param fallback #TRUE to handle messages to children of this path
381  * @param path NULL-terminated array of path elements giving path to subtree
382  * @param vtable the vtable used to traverse this subtree
383  * @param user_data user data to pass to methods in the vtable
384  * @returns #FALSE if not enough memory
385  */
386 dbus_bool_t
387 _dbus_object_tree_register (DBusObjectTree              *tree,
388                             dbus_bool_t                  fallback,
389                             const char                 **path,
390                             const DBusObjectPathVTable  *vtable,
391                             void                        *user_data)
392 {
393   DBusObjectSubtree  *subtree;
394
395   _dbus_assert (tree != NULL);
396   _dbus_assert (vtable->message_function != NULL);
397   _dbus_assert (path != NULL);
398
399   subtree = ensure_subtree (tree, path);
400   if (subtree == NULL)
401     return FALSE;
402
403 #ifndef DBUS_DISABLE_CHECKS
404   if (subtree->message_function != NULL)
405     {
406       _dbus_warn ("A handler is already registered for the path starting with path[0] = \"%s\"\n",
407                   path[0] ? path[0] : "null");
408       return FALSE;
409     }
410 #else
411   _dbus_assert (subtree->message_function == NULL);
412 #endif
413
414   subtree->message_function = vtable->message_function;
415   subtree->unregister_function = vtable->unregister_function;
416   subtree->user_data = user_data;
417   subtree->invoke_as_fallback = fallback != FALSE;
418   
419   return TRUE;
420 }
421
422 /**
423  * Unregisters an object subtree that was registered with the
424  * same path.
425  *
426  * @param tree the global object tree
427  * @param path path to the subtree (same as the one passed to _dbus_object_tree_register())
428  */
429 void
430 _dbus_object_tree_unregister_and_unlock (DBusObjectTree          *tree,
431                                          const char             **path)
432 {
433   int i;
434   DBusObjectSubtree *subtree;
435   DBusObjectPathUnregisterFunction unregister_function;
436   void *user_data;
437   DBusConnection *connection;
438
439   _dbus_assert (path != NULL);
440
441   subtree = find_subtree (tree, path, &i);
442
443 #ifndef DBUS_DISABLE_CHECKS
444   if (subtree == NULL)
445     {
446       _dbus_warn ("Attempted to unregister path (path[0] = %s path[1] = %s) which isn't registered\n",
447                   path[0] ? path[0] : "null",
448                   path[1] ? path[1] : "null");
449       return;
450     }
451 #else
452   _dbus_assert (subtree != NULL);
453 #endif
454
455   _dbus_assert (subtree->parent == NULL ||
456                 (i >= 0 && subtree->parent->subtrees[i] == subtree));
457
458   subtree->message_function = NULL;
459
460   unregister_function = subtree->unregister_function;
461   user_data = subtree->user_data;
462
463   subtree->unregister_function = NULL;
464   subtree->user_data = NULL;
465
466   /* If we have no subtrees of our own, remove from
467    * our parent (FIXME could also be more aggressive
468    * and remove our parent if it becomes empty)
469    */
470   if (subtree->parent && subtree->n_subtrees == 0)
471     {
472       /* assumes a 0-byte memmove is OK */
473       memmove (&subtree->parent->subtrees[i],
474                &subtree->parent->subtrees[i+1],
475                (subtree->parent->n_subtrees - i - 1) *
476                sizeof (subtree->parent->subtrees[0]));
477       subtree->parent->n_subtrees -= 1;
478
479       subtree->parent = NULL;
480
481       _dbus_object_subtree_unref (subtree);
482     }
483   subtree = NULL;
484
485   connection = tree->connection;
486
487   /* Unlock and call application code */
488 #ifdef DBUS_BUILD_TESTS
489   if (connection)
490 #endif
491     {
492       _dbus_connection_ref_unlocked (connection);
493       _dbus_connection_unlock (connection);
494     }
495
496   if (unregister_function)
497     (* unregister_function) (connection, user_data);
498
499 #ifdef DBUS_BUILD_TESTS
500   if (connection)
501 #endif
502     dbus_connection_unref (connection);
503 }
504
505 static void
506 free_subtree_recurse (DBusConnection    *connection,
507                       DBusObjectSubtree *subtree)
508 {
509   /* Delete them from the end, for slightly
510    * more robustness against odd reentrancy.
511    */
512   while (subtree->n_subtrees > 0)
513     {
514       DBusObjectSubtree *child;
515
516       child = subtree->subtrees[subtree->n_subtrees - 1];
517       subtree->subtrees[subtree->n_subtrees - 1] = NULL;
518       subtree->n_subtrees -= 1;
519       child->parent = NULL;
520
521       free_subtree_recurse (connection, child);
522     }
523
524   /* Call application code */
525   if (subtree->unregister_function)
526     {
527       (* subtree->unregister_function) (connection,
528                                         subtree->user_data);
529       subtree->message_function = NULL;
530       subtree->unregister_function = NULL;
531       subtree->user_data = NULL;
532     }
533
534   /* Now free ourselves */
535   _dbus_object_subtree_unref (subtree);
536 }
537
538 /**
539  * Free all the handlers in the tree. Lock on tree's connection
540  * must not be held.
541  *
542  * @param tree the object tree
543  */
544 void
545 _dbus_object_tree_free_all_unlocked (DBusObjectTree *tree)
546 {
547   if (tree->root)
548     free_subtree_recurse (tree->connection,
549                           tree->root);
550   tree->root = NULL;
551 }
552
553 static dbus_bool_t
554 _dbus_object_tree_list_registered_unlocked (DBusObjectTree *tree,
555                                             const char    **parent_path,
556                                             char         ***child_entries)
557 {
558   DBusObjectSubtree *subtree;
559   char **retval;
560   
561   _dbus_assert (parent_path != NULL);
562   _dbus_assert (child_entries != NULL);
563
564   *child_entries = NULL;
565   
566   subtree = lookup_subtree (tree, parent_path);
567   if (subtree == NULL)
568     {
569       retval = dbus_new0 (char *, 1);
570     }
571   else
572     {
573       int i;
574       retval = dbus_new0 (char*, subtree->n_subtrees + 1);
575       if (retval == NULL)
576         goto out;
577       i = 0;
578       while (i < subtree->n_subtrees)
579         {
580           retval[i] = _dbus_strdup (subtree->subtrees[i]->name);
581           if (retval[i] == NULL)
582             {
583               dbus_free_string_array (retval);
584               retval = NULL;
585               goto out;
586             }
587           ++i;
588         }
589     }
590
591  out:
592     
593   *child_entries = retval;
594   return retval != NULL;
595 }
596
597 static DBusHandlerResult
598 handle_default_introspect_unlocked (DBusObjectTree          *tree,
599                                     DBusMessage             *message,
600                                     const char             **path)
601 {
602   DBusString xml;
603   DBusHandlerResult result;
604   char **children;
605   int i;
606
607   if (!dbus_message_is_method_call (message,
608                                     DBUS_INTERFACE_ORG_FREEDESKTOP_INTROSPECTABLE,
609                                     "Introspect"))
610     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
611   
612   if (!_dbus_string_init (&xml))
613     return DBUS_HANDLER_RESULT_NEED_MEMORY;
614
615   result = DBUS_HANDLER_RESULT_NEED_MEMORY;
616
617   children = NULL;
618   if (!_dbus_object_tree_list_registered_unlocked (tree, path, &children))
619     goto out;
620
621   if (!_dbus_string_append (&xml, "<node>\n"))
622     goto out;
623
624   i = 0;
625   while (children[i] != NULL)
626     {
627       if (!_dbus_string_append_printf (&xml, "  <node name=\"%s\"/>\n",
628                                        children[i]))
629         goto out;
630
631       ++i;
632     }
633
634   if (!_dbus_string_append (&xml, "</node>\n"))
635     goto out;
636   
637   result = DBUS_HANDLER_RESULT_HANDLED;
638   
639  out:
640   _dbus_string_free (&xml);
641   dbus_free_string_array (children);
642   
643   return result;
644 }
645
646 /**
647  * Tries to dispatch a message by directing it to handler for the
648  * object path listed in the message header, if any. Messages are
649  * dispatched first to the registered handler that matches the largest
650  * number of path elements; that is, message to /foo/bar/baz would go
651  * to the handler for /foo/bar before the one for /foo.
652  *
653  * @todo thread problems
654  *
655  * @param tree the global object tree
656  * @param message the message to dispatch
657  * @returns whether message was handled successfully
658  */
659 DBusHandlerResult
660 _dbus_object_tree_dispatch_and_unlock (DBusObjectTree          *tree,
661                                        DBusMessage             *message)
662 {
663   char **path;
664   DBusList *list;
665   DBusList *link;
666   DBusHandlerResult result;
667   DBusObjectSubtree *subtree;
668   
669 #if 0
670   _dbus_verbose ("Dispatch of message by object path\n");
671 #endif
672   
673   path = NULL;
674   if (!dbus_message_get_path_decomposed (message, &path))
675     {
676 #ifdef DBUS_BUILD_TESTS
677       if (tree->connection)
678 #endif
679         _dbus_connection_unlock (tree->connection);
680       
681       _dbus_verbose ("No memory to get decomposed path\n");
682
683       return DBUS_HANDLER_RESULT_NEED_MEMORY;
684     }
685
686   if (path == NULL)
687     {
688 #ifdef DBUS_BUILD_TESTS
689       if (tree->connection)
690 #endif
691         _dbus_connection_unlock (tree->connection);
692       
693       _dbus_verbose ("No path field in message\n");
694       return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
695     }
696   
697   /* Find the deepest path that covers the path in the message */
698   subtree = find_handler (tree, (const char**) path);
699   
700   /* Build a list of all paths that cover the path in the message */
701
702   list = NULL;
703
704   while (subtree != NULL)
705     {
706       if (subtree->message_function != NULL)
707         {
708           _dbus_object_subtree_ref (subtree);
709
710           /* run deepest paths first */
711           if (!_dbus_list_append (&list, subtree))
712             {
713               result = DBUS_HANDLER_RESULT_NEED_MEMORY;
714               _dbus_object_subtree_unref (subtree);
715               goto free_and_return;
716             }
717         }
718
719       subtree = subtree->parent;
720     }
721
722   _dbus_verbose ("%d handlers in the path tree for this message\n",
723                  _dbus_list_get_length (&list));
724
725   /* Invoke each handler in the list */
726
727   result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
728
729   link = _dbus_list_get_first_link (&list);
730   while (link != NULL)
731     {
732       DBusList *next = _dbus_list_get_next_link (&list, link);
733       subtree = link->data;
734
735       /* message_function is NULL if we're unregistered
736        * due to reentrancy
737        */
738       if (subtree->message_function)
739         {
740           DBusObjectPathMessageFunction message_function;
741           void *user_data;
742
743           message_function = subtree->message_function;
744           user_data = subtree->user_data;
745
746 #if 0
747           _dbus_verbose ("  (invoking a handler)\n");
748 #endif
749           
750 #ifdef DBUS_BUILD_TESTS
751           if (tree->connection)
752 #endif
753             _dbus_connection_unlock (tree->connection);
754
755           /* FIXME you could unregister the subtree in another thread
756            * before we invoke the callback, and I can't figure out a
757            * good way to solve this.
758            */
759
760           result = (* message_function) (tree->connection,
761                                          message,
762                                          user_data);
763
764 #ifdef DBUS_BUILD_TESTS
765           if (tree->connection)
766 #endif
767             _dbus_connection_lock (tree->connection);
768
769           if (result != DBUS_HANDLER_RESULT_NOT_YET_HANDLED)
770             goto free_and_return;
771         }
772
773       link = next;
774     }
775
776  free_and_return:
777
778   if (result == DBUS_HANDLER_RESULT_NOT_YET_HANDLED)
779     {
780       /* This hardcoded default handler does a minimal Introspect()
781        */
782       result = handle_default_introspect_unlocked (tree, message,
783                                                    (const char**) path);
784     }
785
786 #ifdef DBUS_BUILD_TESTS
787   if (tree->connection)
788 #endif
789     _dbus_connection_unlock (tree->connection);
790   
791   while (list != NULL)
792     {
793       link = _dbus_list_get_first_link (&list);
794       _dbus_object_subtree_unref (link->data);
795       _dbus_list_remove_link (&list, link);
796     }
797   
798   dbus_free_string_array (path);
799
800   return result;
801 }
802
803 /**
804  * Allocates a subtree object.
805  *
806  * @param name name to duplicate.
807  * @returns newly-allocated subtree
808  */
809 static DBusObjectSubtree*
810 allocate_subtree_object (const char *name)
811 {
812   int len;
813   DBusObjectSubtree *subtree;
814   const size_t front_padding = _DBUS_STRUCT_OFFSET (DBusObjectSubtree, name);
815
816   _dbus_assert (name != NULL);
817
818   len = strlen (name);
819
820   subtree = dbus_malloc (front_padding + (len + 1));
821
822   if (subtree == NULL)
823     return NULL;
824
825   memcpy (subtree->name, name, len + 1);
826
827   return subtree;
828 }
829
830 static DBusObjectSubtree*
831 _dbus_object_subtree_new (const char                  *name,
832                           const DBusObjectPathVTable  *vtable,
833                           void                        *user_data)
834 {
835   DBusObjectSubtree *subtree;
836
837   subtree = allocate_subtree_object (name);
838   if (subtree == NULL)
839     goto oom;
840
841   _dbus_assert (name != NULL);
842
843   subtree->parent = NULL;
844
845   if (vtable)
846     {
847       subtree->message_function = vtable->message_function;
848       subtree->unregister_function = vtable->unregister_function;
849     }
850   else
851     {
852       subtree->message_function = NULL;
853       subtree->unregister_function = NULL;
854     }
855
856   subtree->user_data = user_data;
857   subtree->refcount.value = 1;
858   subtree->subtrees = NULL;
859   subtree->n_subtrees = 0;
860   subtree->subtrees_sorted = TRUE;
861   
862   return subtree;
863
864  oom:
865   if (subtree)
866     {
867       dbus_free (subtree);
868     }
869
870   return NULL;
871 }
872
873 static DBusObjectSubtree *
874 _dbus_object_subtree_ref (DBusObjectSubtree *subtree)
875 {
876   _dbus_assert (subtree->refcount.value > 0);
877   _dbus_atomic_inc (&subtree->refcount);
878
879   return subtree;
880 }
881
882 static void
883 _dbus_object_subtree_unref (DBusObjectSubtree *subtree)
884 {
885   _dbus_assert (subtree->refcount.value > 0);
886
887   if (_dbus_atomic_dec (&subtree->refcount) == 1)
888     {
889       _dbus_assert (subtree->unregister_function == NULL);
890       _dbus_assert (subtree->message_function == NULL);
891
892       dbus_free (subtree->subtrees);
893       dbus_free (subtree);
894     }
895 }
896
897 /**
898  * Lists the registered fallback handlers and object path handlers at
899  * the given parent_path. The returned array should be freed with
900  * dbus_free_string_array().
901  *
902  * @param connection the connection
903  * @param parent_path the path to list the child handlers of
904  * @param child_entries returns #NULL-terminated array of children
905  * @returns #FALSE if no memory to allocate the child entries
906  */
907 dbus_bool_t
908 _dbus_object_tree_list_registered_and_unlock (DBusObjectTree *tree,
909                                               const char    **parent_path,
910                                               char         ***child_entries)
911 {
912   dbus_bool_t result;
913
914   result = _dbus_object_tree_list_registered_unlocked (tree,
915                                                        parent_path,
916                                                        child_entries);
917   
918 #ifdef DBUS_BUILD_TESTS
919   if (tree->connection)
920 #endif
921     _dbus_connection_unlock (tree->connection);
922
923   return result;
924 }
925      
926 /** @} */
927
928 #ifdef DBUS_BUILD_TESTS
929 #include "dbus-test.h"
930 #include <stdio.h>
931
932 static char*
933 flatten_path (const char **path)
934 {
935   DBusString str;
936   int i;
937   char *s;
938
939   if (!_dbus_string_init (&str))
940     return NULL;
941
942   i = 0;
943   while (path[i])
944     {
945       if (!_dbus_string_append_byte (&str, '/'))
946         goto nomem;
947
948       if (!_dbus_string_append (&str, path[i]))
949         goto nomem;
950
951       ++i;
952     }
953
954   if (!_dbus_string_steal_data (&str, &s))
955     goto nomem;
956
957   _dbus_string_free (&str);
958
959   return s;
960
961  nomem:
962   _dbus_string_free (&str);
963   return NULL;
964 }
965
966 /* Returns TRUE if container is a parent of child
967  */
968 static dbus_bool_t
969 path_contains (const char **container,
970                const char **child)
971 {
972   int i;
973
974   i = 0;
975   while (child[i] != NULL)
976     {
977       int v;
978
979       if (container[i] == NULL)
980         return TRUE; /* container ran out, child continues;
981                       * thus the container is a parent of the
982                       * child.
983                       */
984
985       _dbus_assert (container[i] != NULL);
986       _dbus_assert (child[i] != NULL);
987
988       v = strcmp (container[i], child[i]);
989
990       if (v != 0)
991         return FALSE; /* they overlap until here and then are different,
992                        * not overlapping
993                        */
994
995       ++i;
996     }
997
998   /* Child ran out; if container also did, they are equal;
999    * otherwise, the child is a parent of the container.
1000    */
1001   if (container[i] == NULL)
1002     return TRUE; /* equal is counted as containing */
1003   else
1004     return FALSE;
1005 }
1006
1007 static void
1008 spew_subtree_recurse (DBusObjectSubtree *subtree,
1009                       int                indent)
1010 {
1011   int i;
1012
1013   i = 0;
1014   while (i < indent)
1015     {
1016       _dbus_verbose (" ");
1017       ++i;
1018     }
1019
1020   _dbus_verbose ("%s (%d children)\n",
1021                  subtree->name, subtree->n_subtrees);
1022
1023   i = 0;
1024   while (i < subtree->n_subtrees)
1025     {
1026       spew_subtree_recurse (subtree->subtrees[i], indent + 2);
1027
1028       ++i;
1029     }
1030 }
1031
1032 static void
1033 spew_tree (DBusObjectTree *tree)
1034 {
1035   spew_subtree_recurse (tree->root, 0);
1036 }
1037
1038 /**
1039  * Callback data used in tests
1040  */
1041 typedef struct
1042 {
1043   const char **path; /**< Path */
1044   dbus_bool_t message_handled; /**< Gets set to true if message handler called */
1045   dbus_bool_t handler_unregistered; /**< gets set to true if handler is unregistered */
1046
1047 } TreeTestData;
1048
1049
1050 static void
1051 test_unregister_function (DBusConnection  *connection,
1052                           void            *user_data)
1053 {
1054   TreeTestData *ttd = user_data;
1055
1056   ttd->handler_unregistered = TRUE;
1057 }
1058
1059 static DBusHandlerResult
1060 test_message_function (DBusConnection  *connection,
1061                        DBusMessage     *message,
1062                        void            *user_data)
1063 {
1064   TreeTestData *ttd = user_data;
1065
1066   ttd->message_handled = TRUE;
1067
1068   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1069 }
1070
1071 static dbus_bool_t
1072 do_register (DBusObjectTree *tree,
1073              const char    **path,
1074              int             i,
1075              TreeTestData   *tree_test_data)
1076 {
1077   DBusObjectPathVTable vtable = { test_unregister_function,
1078                                   test_message_function, NULL };
1079
1080   tree_test_data[i].message_handled = FALSE;
1081   tree_test_data[i].handler_unregistered = FALSE;
1082   tree_test_data[i].path = path;
1083
1084   if (!_dbus_object_tree_register (tree, TRUE, path,
1085                                    &vtable,
1086                                    &tree_test_data[i]))
1087     return FALSE;
1088
1089   return TRUE;
1090 }
1091
1092 static dbus_bool_t
1093 do_test_dispatch (DBusObjectTree *tree,
1094                   const char    **path,
1095                   int             i,
1096                   TreeTestData   *tree_test_data,
1097                   int             n_test_data)
1098 {
1099   DBusMessage *message;
1100   int j;
1101   DBusHandlerResult result;
1102   char *flat;
1103
1104   message = NULL;
1105   
1106   flat = flatten_path (path);
1107   if (flat == NULL)
1108     goto oom;
1109
1110   message = dbus_message_new_method_call (NULL,
1111                                           flat,
1112                                           "org.freedesktop.TestInterface",
1113                                           "Foo");
1114   dbus_free (flat);
1115   if (message == NULL)
1116     goto oom;
1117
1118   j = 0;
1119   while (j < n_test_data)
1120     {
1121       tree_test_data[j].message_handled = FALSE;
1122       ++j;
1123     }
1124
1125   result = _dbus_object_tree_dispatch_and_unlock (tree, message);
1126   if (result == DBUS_HANDLER_RESULT_NEED_MEMORY)
1127     goto oom;
1128
1129   _dbus_assert (tree_test_data[i].message_handled);
1130
1131   j = 0;
1132   while (j < n_test_data)
1133     {
1134       if (tree_test_data[j].message_handled)
1135         _dbus_assert (path_contains (tree_test_data[j].path,
1136                                      path));
1137       else
1138         _dbus_assert (!path_contains (tree_test_data[j].path,
1139                                       path));
1140
1141       ++j;
1142     }
1143
1144   dbus_message_unref (message);
1145
1146   return TRUE;
1147
1148  oom:
1149   if (message)
1150     dbus_message_unref (message);
1151   return FALSE;
1152 }
1153
1154 static size_t
1155 string_array_length (char **array)
1156 {
1157   size_t i;
1158   for (i = 0; array[i]; i++) ;
1159   return i;
1160 }
1161
1162
1163 static dbus_bool_t
1164 object_tree_test_iteration (void *data)
1165 {
1166   const char *path1[] = { "foo", NULL };
1167   const char *path2[] = { "foo", "bar", NULL };
1168   const char *path3[] = { "foo", "bar", "baz", NULL };
1169   const char *path4[] = { "foo", "bar", "boo", NULL };
1170   const char *path5[] = { "blah", NULL };
1171   const char *path6[] = { "blah", "boof", NULL };
1172   const char *path7[] = { "blah", "boof", "this", "is", "really", "long", NULL };
1173   const char *path8[] = { "childless", NULL };
1174   DBusObjectTree *tree;
1175   TreeTestData tree_test_data[8];
1176   int i;
1177
1178   tree = NULL;
1179
1180   tree = _dbus_object_tree_new (NULL);
1181   if (tree == NULL)
1182     goto out;
1183
1184   if (!do_register (tree, path1, 0, tree_test_data))
1185     goto out;
1186
1187   _dbus_assert (find_subtree (tree, path1, NULL));
1188   _dbus_assert (!find_subtree (tree, path2, NULL));
1189   _dbus_assert (!find_subtree (tree, path3, NULL));
1190   _dbus_assert (!find_subtree (tree, path4, NULL));
1191   _dbus_assert (!find_subtree (tree, path5, NULL));
1192   _dbus_assert (!find_subtree (tree, path6, NULL));
1193   _dbus_assert (!find_subtree (tree, path7, NULL));
1194   _dbus_assert (!find_subtree (tree, path8, NULL));
1195
1196   _dbus_assert (find_handler (tree, path1));
1197   _dbus_assert (find_handler (tree, path2));
1198   _dbus_assert (find_handler (tree, path3));
1199   _dbus_assert (find_handler (tree, path4));
1200   _dbus_assert (find_handler (tree, path5) == tree->root);
1201   _dbus_assert (find_handler (tree, path6) == tree->root);
1202   _dbus_assert (find_handler (tree, path7) == tree->root);
1203   _dbus_assert (find_handler (tree, path8) == tree->root);
1204
1205   if (!do_register (tree, path2, 1, tree_test_data))
1206     goto out;
1207
1208   _dbus_assert (find_subtree (tree, path1, NULL));
1209   _dbus_assert (find_subtree (tree, path2, NULL));
1210   _dbus_assert (!find_subtree (tree, path3, NULL));
1211   _dbus_assert (!find_subtree (tree, path4, NULL));
1212   _dbus_assert (!find_subtree (tree, path5, NULL));
1213   _dbus_assert (!find_subtree (tree, path6, NULL));
1214   _dbus_assert (!find_subtree (tree, path7, NULL));
1215   _dbus_assert (!find_subtree (tree, path8, NULL));
1216
1217   if (!do_register (tree, path3, 2, tree_test_data))
1218     goto out;
1219
1220   _dbus_assert (find_subtree (tree, path1, NULL));
1221   _dbus_assert (find_subtree (tree, path2, NULL));
1222   _dbus_assert (find_subtree (tree, path3, NULL));
1223   _dbus_assert (!find_subtree (tree, path4, NULL));
1224   _dbus_assert (!find_subtree (tree, path5, NULL));
1225   _dbus_assert (!find_subtree (tree, path6, NULL));
1226   _dbus_assert (!find_subtree (tree, path7, NULL));
1227   _dbus_assert (!find_subtree (tree, path8, NULL));
1228   
1229   if (!do_register (tree, path4, 3, tree_test_data))
1230     goto out;
1231
1232   _dbus_assert (find_subtree (tree, path1, NULL));
1233   _dbus_assert (find_subtree (tree, path2, NULL));
1234   _dbus_assert (find_subtree (tree, path3, NULL));  
1235   _dbus_assert (find_subtree (tree, path4, NULL));
1236   _dbus_assert (!find_subtree (tree, path5, NULL));
1237   _dbus_assert (!find_subtree (tree, path6, NULL));
1238   _dbus_assert (!find_subtree (tree, path7, NULL));
1239   _dbus_assert (!find_subtree (tree, path8, NULL));
1240   
1241   if (!do_register (tree, path5, 4, tree_test_data))
1242     goto out;
1243
1244   _dbus_assert (find_subtree (tree, path1, NULL));
1245   _dbus_assert (find_subtree (tree, path2, NULL));
1246   _dbus_assert (find_subtree (tree, path3, NULL));
1247   _dbus_assert (find_subtree (tree, path4, NULL));
1248   _dbus_assert (find_subtree (tree, path5, NULL));
1249   _dbus_assert (!find_subtree (tree, path6, NULL));
1250   _dbus_assert (!find_subtree (tree, path7, NULL));
1251   _dbus_assert (!find_subtree (tree, path8, NULL));
1252   
1253   _dbus_assert (find_handler (tree, path1) != tree->root);
1254   _dbus_assert (find_handler (tree, path2) != tree->root);
1255   _dbus_assert (find_handler (tree, path3) != tree->root);
1256   _dbus_assert (find_handler (tree, path4) != tree->root);
1257   _dbus_assert (find_handler (tree, path5) != tree->root);
1258   _dbus_assert (find_handler (tree, path6) != tree->root);
1259   _dbus_assert (find_handler (tree, path7) != tree->root);
1260   _dbus_assert (find_handler (tree, path8) == tree->root);
1261
1262   if (!do_register (tree, path6, 5, tree_test_data))
1263     goto out;
1264
1265   _dbus_assert (find_subtree (tree, path1, NULL));
1266   _dbus_assert (find_subtree (tree, path2, NULL));
1267   _dbus_assert (find_subtree (tree, path3, NULL));
1268   _dbus_assert (find_subtree (tree, path4, NULL));
1269   _dbus_assert (find_subtree (tree, path5, NULL));
1270   _dbus_assert (find_subtree (tree, path6, NULL));
1271   _dbus_assert (!find_subtree (tree, path7, NULL));
1272   _dbus_assert (!find_subtree (tree, path8, NULL));
1273
1274   if (!do_register (tree, path7, 6, tree_test_data))
1275     goto out;
1276
1277   _dbus_assert (find_subtree (tree, path1, NULL));
1278   _dbus_assert (find_subtree (tree, path2, NULL));
1279   _dbus_assert (find_subtree (tree, path3, NULL));
1280   _dbus_assert (find_subtree (tree, path4, NULL));
1281   _dbus_assert (find_subtree (tree, path5, NULL));
1282   _dbus_assert (find_subtree (tree, path6, NULL));
1283   _dbus_assert (find_subtree (tree, path7, NULL));
1284   _dbus_assert (!find_subtree (tree, path8, NULL));
1285
1286   if (!do_register (tree, path8, 7, tree_test_data))
1287     goto out;
1288
1289   _dbus_assert (find_subtree (tree, path1, NULL));
1290   _dbus_assert (find_subtree (tree, path2, NULL));
1291   _dbus_assert (find_subtree (tree, path3, NULL));
1292   _dbus_assert (find_subtree (tree, path4, NULL));
1293   _dbus_assert (find_subtree (tree, path5, NULL));
1294   _dbus_assert (find_subtree (tree, path6, NULL));
1295   _dbus_assert (find_subtree (tree, path7, NULL));
1296   _dbus_assert (find_subtree (tree, path8, NULL));
1297   
1298   _dbus_assert (find_handler (tree, path1) != tree->root);
1299   _dbus_assert (find_handler (tree, path2) != tree->root);
1300   _dbus_assert (find_handler (tree, path3) != tree->root);
1301   _dbus_assert (find_handler (tree, path4) != tree->root);
1302   _dbus_assert (find_handler (tree, path5) != tree->root);
1303   _dbus_assert (find_handler (tree, path6) != tree->root);
1304   _dbus_assert (find_handler (tree, path7) != tree->root);
1305   _dbus_assert (find_handler (tree, path8) != tree->root);
1306   
1307   /* test the list_registered function */
1308
1309   {
1310     const char *root[] = { NULL };
1311     char **child_entries;
1312     int nb;
1313
1314     _dbus_object_tree_list_registered_unlocked (tree, path1, &child_entries);
1315     if (child_entries != NULL)
1316       {
1317         nb = string_array_length (child_entries);
1318         _dbus_assert (nb == 1);
1319         dbus_free_string_array (child_entries);
1320       }
1321
1322     _dbus_object_tree_list_registered_unlocked (tree, path2, &child_entries);
1323     if (child_entries != NULL)
1324       {
1325         nb = string_array_length (child_entries);
1326         _dbus_assert (nb == 2);
1327         dbus_free_string_array (child_entries);
1328       }
1329
1330     _dbus_object_tree_list_registered_unlocked (tree, path8, &child_entries);
1331     if (child_entries != NULL)
1332       {
1333         nb = string_array_length (child_entries);
1334         _dbus_assert (nb == 0);
1335         dbus_free_string_array (child_entries);
1336       }
1337
1338     _dbus_object_tree_list_registered_unlocked (tree, root, &child_entries);
1339     if (child_entries != NULL)
1340       {
1341         nb = string_array_length (child_entries);
1342         _dbus_assert (nb == 3);
1343         dbus_free_string_array (child_entries);
1344       }
1345   }
1346
1347   /* Check that destroying tree calls unregister funcs */
1348   _dbus_object_tree_unref (tree);
1349
1350   i = 0;
1351   while (i < (int) _DBUS_N_ELEMENTS (tree_test_data))
1352     {
1353       _dbus_assert (tree_test_data[i].handler_unregistered);
1354       _dbus_assert (!tree_test_data[i].message_handled);
1355       ++i;
1356     }
1357
1358   /* Now start again and try the individual unregister function */
1359   tree = _dbus_object_tree_new (NULL);
1360   if (tree == NULL)
1361     goto out;
1362
1363   if (!do_register (tree, path1, 0, tree_test_data))
1364     goto out;
1365   if (!do_register (tree, path2, 1, tree_test_data))
1366     goto out;
1367   if (!do_register (tree, path3, 2, tree_test_data))
1368     goto out;
1369   if (!do_register (tree, path4, 3, tree_test_data))
1370     goto out;
1371   if (!do_register (tree, path5, 4, tree_test_data))
1372     goto out;
1373   if (!do_register (tree, path6, 5, tree_test_data))
1374     goto out;
1375   if (!do_register (tree, path7, 6, tree_test_data))
1376     goto out;
1377   if (!do_register (tree, path8, 7, tree_test_data))
1378     goto out;
1379   
1380   _dbus_object_tree_unregister_and_unlock (tree, path1);
1381
1382   _dbus_assert (!find_subtree (tree, path1, NULL));
1383   _dbus_assert (find_subtree (tree, path2, NULL));
1384   _dbus_assert (find_subtree (tree, path3, NULL));
1385   _dbus_assert (find_subtree (tree, path4, NULL));
1386   _dbus_assert (find_subtree (tree, path5, NULL));
1387   _dbus_assert (find_subtree (tree, path6, NULL));
1388   _dbus_assert (find_subtree (tree, path7, NULL));
1389   _dbus_assert (find_subtree (tree, path8, NULL));
1390
1391   _dbus_object_tree_unregister_and_unlock (tree, path2);
1392
1393   _dbus_assert (!find_subtree (tree, path1, NULL));
1394   _dbus_assert (!find_subtree (tree, path2, NULL));
1395   _dbus_assert (find_subtree (tree, path3, NULL));
1396   _dbus_assert (find_subtree (tree, path4, NULL));
1397   _dbus_assert (find_subtree (tree, path5, NULL));
1398   _dbus_assert (find_subtree (tree, path6, NULL));
1399   _dbus_assert (find_subtree (tree, path7, NULL));
1400   _dbus_assert (find_subtree (tree, path8, NULL));
1401   
1402   _dbus_object_tree_unregister_and_unlock (tree, path3);
1403
1404   _dbus_assert (!find_subtree (tree, path1, NULL));
1405   _dbus_assert (!find_subtree (tree, path2, NULL));
1406   _dbus_assert (!find_subtree (tree, path3, NULL));
1407   _dbus_assert (find_subtree (tree, path4, NULL));
1408   _dbus_assert (find_subtree (tree, path5, NULL));
1409   _dbus_assert (find_subtree (tree, path6, NULL));
1410   _dbus_assert (find_subtree (tree, path7, NULL));
1411   _dbus_assert (find_subtree (tree, path8, NULL));
1412   
1413   _dbus_object_tree_unregister_and_unlock (tree, path4);
1414
1415   _dbus_assert (!find_subtree (tree, path1, NULL));
1416   _dbus_assert (!find_subtree (tree, path2, NULL));
1417   _dbus_assert (!find_subtree (tree, path3, NULL));
1418   _dbus_assert (!find_subtree (tree, path4, NULL));
1419   _dbus_assert (find_subtree (tree, path5, NULL));
1420   _dbus_assert (find_subtree (tree, path6, NULL));
1421   _dbus_assert (find_subtree (tree, path7, NULL));
1422   _dbus_assert (find_subtree (tree, path8, NULL));
1423   
1424   _dbus_object_tree_unregister_and_unlock (tree, path5);
1425
1426   _dbus_assert (!find_subtree (tree, path1, NULL));
1427   _dbus_assert (!find_subtree (tree, path2, NULL));
1428   _dbus_assert (!find_subtree (tree, path3, NULL));
1429   _dbus_assert (!find_subtree (tree, path4, NULL));
1430   _dbus_assert (!find_subtree (tree, path5, NULL));
1431   _dbus_assert (find_subtree (tree, path6, NULL));
1432   _dbus_assert (find_subtree (tree, path7, NULL));
1433   _dbus_assert (find_subtree (tree, path8, NULL));
1434   
1435   _dbus_object_tree_unregister_and_unlock (tree, path6);
1436
1437   _dbus_assert (!find_subtree (tree, path1, NULL));
1438   _dbus_assert (!find_subtree (tree, path2, NULL));
1439   _dbus_assert (!find_subtree (tree, path3, NULL));
1440   _dbus_assert (!find_subtree (tree, path4, NULL));
1441   _dbus_assert (!find_subtree (tree, path5, NULL));
1442   _dbus_assert (!find_subtree (tree, path6, NULL));
1443   _dbus_assert (find_subtree (tree, path7, NULL));
1444   _dbus_assert (find_subtree (tree, path8, NULL));
1445
1446   _dbus_object_tree_unregister_and_unlock (tree, path7);
1447
1448   _dbus_assert (!find_subtree (tree, path1, NULL));
1449   _dbus_assert (!find_subtree (tree, path2, NULL));
1450   _dbus_assert (!find_subtree (tree, path3, NULL));
1451   _dbus_assert (!find_subtree (tree, path4, NULL));
1452   _dbus_assert (!find_subtree (tree, path5, NULL));
1453   _dbus_assert (!find_subtree (tree, path6, NULL));
1454   _dbus_assert (!find_subtree (tree, path7, NULL));
1455   _dbus_assert (find_subtree (tree, path8, NULL));
1456
1457   _dbus_object_tree_unregister_and_unlock (tree, path8);
1458
1459   _dbus_assert (!find_subtree (tree, path1, NULL));
1460   _dbus_assert (!find_subtree (tree, path2, NULL));
1461   _dbus_assert (!find_subtree (tree, path3, NULL));
1462   _dbus_assert (!find_subtree (tree, path4, NULL));
1463   _dbus_assert (!find_subtree (tree, path5, NULL));
1464   _dbus_assert (!find_subtree (tree, path6, NULL));
1465   _dbus_assert (!find_subtree (tree, path7, NULL));
1466   _dbus_assert (!find_subtree (tree, path8, NULL));
1467   
1468   i = 0;
1469   while (i < (int) _DBUS_N_ELEMENTS (tree_test_data))
1470     {
1471       _dbus_assert (tree_test_data[i].handler_unregistered);
1472       _dbus_assert (!tree_test_data[i].message_handled);
1473       ++i;
1474     }
1475
1476   /* Register it all again, and test dispatch */
1477
1478   if (!do_register (tree, path1, 0, tree_test_data))
1479     goto out;
1480   if (!do_register (tree, path2, 1, tree_test_data))
1481     goto out;
1482   if (!do_register (tree, path3, 2, tree_test_data))
1483     goto out;
1484   if (!do_register (tree, path4, 3, tree_test_data))
1485     goto out;
1486   if (!do_register (tree, path5, 4, tree_test_data))
1487     goto out;
1488   if (!do_register (tree, path6, 5, tree_test_data))
1489     goto out;
1490   if (!do_register (tree, path7, 6, tree_test_data))
1491     goto out;
1492   if (!do_register (tree, path8, 7, tree_test_data))
1493     goto out;
1494
1495 #if 0
1496   spew_tree (tree);
1497 #endif
1498   
1499   if (!do_test_dispatch (tree, path1, 0, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
1500     goto out;
1501   if (!do_test_dispatch (tree, path2, 1, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
1502     goto out;
1503   if (!do_test_dispatch (tree, path3, 2, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
1504     goto out;
1505   if (!do_test_dispatch (tree, path4, 3, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
1506     goto out;
1507   if (!do_test_dispatch (tree, path5, 4, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
1508     goto out;
1509   if (!do_test_dispatch (tree, path6, 5, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
1510     goto out;
1511   if (!do_test_dispatch (tree, path7, 6, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
1512     goto out;
1513   if (!do_test_dispatch (tree, path8, 7, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
1514     goto out;
1515   
1516  out:
1517   if (tree)
1518     {
1519       /* test ref */
1520       _dbus_object_tree_ref (tree);
1521       _dbus_object_tree_unref (tree);
1522       _dbus_object_tree_unref (tree);
1523     }
1524
1525   return TRUE;
1526 }
1527
1528 /**
1529  * @ingroup DBusObjectTree
1530  * Unit test for DBusObjectTree
1531  * @returns #TRUE on success.
1532  */
1533 dbus_bool_t
1534 _dbus_object_tree_test (void)
1535 {
1536   _dbus_test_oom_handling ("object tree",
1537                            object_tree_test_iteration,
1538                            NULL);
1539
1540   return TRUE;
1541 }
1542
1543 #endif /* DBUS_BUILD_TESTS */