2003-09-29 Havoc Pennington <hp@pobox.com>

	* Merge dbus-object-names branch. To see the entire patch
	do cvs diff -r DBUS_OBJECT_NAMES_BRANCHPOINT -r dbus-object-names,
	it's huuuuge though.
	To revert, I tagged DBUS_BEFORE_OBJECT_NAMES_MERGE.

2003-09-28  Havoc Pennington  <hp@pobox.com>

	* HACKING: update to reflect new server

2003-09-26  Seth Nickell  <seth@gnome.org>

	* python/dbus.py:
	* python/examples/example-signals.py:

	Start implementing some notions of signals. The API
	is really terrible, but they sort of work (with the
	exception of being able to filter by service, and to
	transmit signals *as* a particular service). Need to
	figure out how to make messages come from the service
	we registered :-(

	* python/dbus_bindings.pyx.in:

	Removed duplicate message_handler callbacks.

2003-09-25  Havoc Pennington  <hp@redhat.com>

	* bus/session.conf.in: fix my mess

2003-09-25  Havoc Pennington  <hp@pobox.com>

	* bus/session.conf.in: fix security policy, reported by Seth Nickell

2003-09-25  Seth Nickell  <seth@gnome.org>

	* python/examples/example-service.py:

	Johan notices complete wrong code in example-service, but
	completely wrong in a way that works exactly the same (!).
	Johan is confused, how could this possibly work? Example
	code fails to serve purpose of making things clear.
	Seth fixes.

2003-09-25  Mark McLoughlin  <mark@skynet.ie>

	* doc/dbus-specification.sgml: don't require header fields
	to be 4-byte aligned and specify that fields should be
	distinguished from padding by the fact that zero is not
	a valid field name.

	* doc/TODO: remove re-alignment item and add item to doc
	the OBJECT_PATH type.

	* dbus/dbus-message.c:
	(HeaderField): rename the original member to value_offset
	and introduce a name_offset member to keep track of where
	the field actually begins.
	(adjust_field_offsets): remove.
	(append_int_field), (append_uint_field),
	(append_string_field): don't align the start of the header
	field to a 4-byte boundary.
	(get_next_field): impl finding the next marhsalled field
	after a given field.
	(re_align_field_recurse): impl re-aligning a number of
	already marshalled fields.
	(delete_field): impl deleting a field of any type and
	re-aligning any following fields.
	(delete_int_or_uint_field), (delete_string_field): remove.
	(set_int_field), (set_uint_field): no need to re-check
	that we have the correct type for the field.
	(set_string_field): ditto and impl re-aligning any
	following fields.
	(decode_header_data): update to take into account that
	the fields aren't 4-byte aligned any more and the new
	way to distinguish padding from header fields. Also,
	don't exit when there is too much header padding.
	(process_test_subdir): print the directory.
	(_dbus_message_test): add test to make sure a following
	field is re-aligned correctly after field deletion.

	* dbus/dbus-string.[ch]:
	(_dbus_string_insert_bytes): rename from insert_byte and
	allow the insert of multiple bytes.
	(_dbus_string_test): test inserting multiple bytes.

	* dbus/dbus-marshal.c: (_dbus_marshal_set_string): add
	warning note to docs about having to re-align any
	marshalled values following the string.

	* dbus/dbus-message-builder.c:
	(append_string_field), (_dbus_message_data_load):
	don't align the header field.

	* dbus/dbus-auth.c: (process_test_subdir): print the
	directory.

	* test/break-loader.c: (randomly_add_one_byte): upd. for
	insert_byte change.

	* test/data/invalid-messages/bad-header-field-alignment.message:
	new test case.

	* test/data/valid-messages/unknown-header-field.message: shove
	a dict in the unknown field.

2003-09-25  Seth Nickell  <seth@gnome.org>

	* python/dbus.py:
	* python/dbus_bindings.pyx.in:

	Handle return values.

	* python/examples/example-client.py:
	* python/examples/example-service.py:

	Pass back return values from the service to the client.

2003-09-24  Seth Nickell  <seth@gnome.org>

	* python/dbus.py:

	Connect Object methods (when you are sharing an object) up... pass
	in a list of methods to be shared. Sharing all the methods just
	worked out too weird. You can now create nice Services over the
	DBus in Python. :-)

	* python/dbus_bindings.pyx.in:

	Keep references to user_data tuples passed into C functions so
	Python doesn't garbage collect on us.

	Implement MethodReturn and Error subclasses of Message for creating
	DBusMessage's of those types.

	* python/examples/example-client.py:
	* python/examples/example-service.py:

	Simple example code showing both how create DBus services and objects,
	and how to use them.

2003-09-23  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gproxy.c (dbus_gproxy_manager_filter): implement

2003-09-23  Havoc Pennington  <hp@redhat.com>

	* glib/dbus-gproxy.c (dbus_gproxy_connect_signal): implement
	(dbus_gproxy_disconnect_signal): implement
	(dbus_gproxy_manager_remove_signal_match): implement
	(dbus_gproxy_manager_add_signal_match): implement
	(dbus_gproxy_oneway_call): implement

2003-09-23  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gproxy.c (struct DBusGProxy): convert to a GObject
	subclass. This means dropping the transparent thread safety of the
	proxy; you now need a separate proxy per-thread, or your own
	locking on the proxy. Probably right anyway.
	(dbus_gproxy_ref, dbus_gproxy_unref): nuke, just use g_object_ref

2003-09-22  Havoc Pennington  <hp@redhat.com>

	* glib/dbus-gproxy.c (dbus_gproxy_manager_get): implement

2003-09-21  Seth Nickell  <seth@gnome.org>

        First checkin of the Python bindings.

	* python/.cvsignore:
	* python/Makefile.am:
	* python/dbus_bindings.pyx.in:
	* python/dbus_h_wrapper.h:

	Pieces for Pyrex to operate on, building a dbus_bindings.so
	python module for low-level access to the DBus APIs.

	* python/dbus.py:

	High-level Python module for accessing DBus objects.

	* configure.in:
	* Makefile.am:

	Build stuff for the python bindings.

	* acinclude.m4:

	Extra macro needed for finding the Python C header files.

2003-09-21  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gproxy.c (dbus_gproxy_manager_new): start
	implementing the proxy manager, didn't get very far.

	* dbus/dbus-bus.c (dbus_bus_add_match): new
	(dbus_bus_remove_match): new

	* glib/dbus-gproxy.c (dbus_gproxy_new_for_service): add a
	path_name argument; adjust the other not-yet-implemented
	gproxy constructors to be what I think they should be.

2003-09-21  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-bus.c (dbus_bus_get): set exit_on_disconnect to TRUE
	by default for message bus connections.

	* dbus/dbus-connection.c (dbus_connection_dispatch): exit if
	exit_on_disconnect flag is set and we process the disconnected
	signal.
	(dbus_connection_set_exit_on_disconnect): new function

2003-09-21  Havoc Pennington  <hp@pobox.com>

	Get matching rules mostly working in the bus; only actually
	parsing the rule text remains. However, the client side of
	"signal connections" hasn't been started, this patch is only the
	bus side.

	* dbus/dispatch.c: fix for the matching rules changes

	* bus/driver.c (bus_driver_handle_remove_match)
	(bus_driver_handle_add_match): send an ack reply from these
	method calls

	* glib/dbus-gproxy.c (dbus_gproxy_begin_call): fix order of
	arguments, reported by Seth Nickell

	* bus/config-parser.c (append_rule_from_element): support
	eavesdrop=true|false attribute on policies so match rules
	can be prevented from snooping on the system bus.

	* bus/dbus-daemon-1.1.in: consistently use terminology "sender"
	and "destination" in attribute names; fix some docs bugs;
	add eavesdrop=true|false attribute

	* bus/driver.c (bus_driver_handle_add_match)
	(bus_driver_handle_remove_match): handle AddMatch, RemoveMatch
	messages

	* dbus/dbus-protocol.h (DBUS_SERVICE_ORG_FREEDESKTOP_BROADCAST): get
	rid of broadcast service concept, signals are just always broadcast

	* bus/signals.c, bus/dispatch.c, bus/connection.c, bus/bus.c:
	mostly implement matching rules stuff (currently only exposed as signal
	connections)

2003-09-21  Mark McLoughlin  <mark@skynet.ie>

	* doc/dbus-specification.sgml: Change the header field name
	to be an enum and update the rest of the spec to reference
	the fields using the conventinal name.

	* dbus/dbus-protocol.h: update to reflect the spec.

	* doc/TODO: add item to remove the 4 byte alignment requirement.

	* dbus/dbus-message.c: Remove the code to generalise the
	header/body length and serial number header fields as named
	header fields so we can reference field names using the
	protocol values.
	(append_int_field), (append_uint_field), (append_string_field):
	Append the field name as a byte rather than four chars.
	(delete_int_or_uint_field), (delete_string_field): reflect the
	fact that the field name and typecode now occupy 4 bytes instead
	of 8.
	(decode_string_field), (decode_header_data): update to reflect
	protocol changes and move the field specific encoding from
	decode_string_field() back into decode_header_data().

	* dbus/dbus-internals.[ch]: (_dbus_header_field_to_string):
	Add utility to aid debugging.

	* dbus/dbus-message-builder.c:
	(append_string_field), (_dbus_message_data_load): Update to
	reflect protocol changes; Change the FIELD_NAME directive
	to HEADER_FIELD and allow it to take the field's conventional
	name rather than the actual value.

	* test/data/*/*.message: Update to use HEADER_FIELD instead
	of FIELD_NAME; Always align the header on an 8 byte boundary
	*before* updating the header length.

2003-09-15  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-pending-call.c: add the get/set object data
	boilerplate as for DBusConnection, etc. Use generic object data
	for the notify callback.

	* glib/dbus-gparser.c (parse_node): parse child nodes

	* tools/dbus-viewer.c: more hacking on the dbus-viewer

	* glib/dbus-gutils.c (_dbus_gutils_split_path): add a file to
	contain functions shared between the convenience lib and the
	installed lib

	* glib/Makefile.am (libdbus_glib_1_la_LDFLAGS): add
	-export-symbols-regex to the GLib library

	* dbus/dbus-object-tree.c (_dbus_object_tree_dispatch_and_unlock):
	fix the locking in here, and add a default handler for
	Introspect() that just returns sub-nodes.

2003-09-14  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gthread.c (dbus_g_thread_init): rename to make g_foo
	rather than gfoo consistent

	* glib/dbus-gproxy.h: delete for now, move contents to
	dbus-glib.h, because the include files don't work right since we
	aren't in the dbus/ subdir.

	* glib/dbus-gproxy.c (dbus_gproxy_send): finish implementing
	(dbus_gproxy_end_call): finish
	(dbus_gproxy_begin_call): finish

	* glib/dbus-gmain.c (dbus_set_g_error): new

	* glib/dbus-gobject.c (handle_introspect): include information
	about child nodes in the introspection

	* dbus/dbus-connection.c (dbus_connection_list_registered): new
	function to help in implementation of introspection

	* dbus/dbus-object-tree.c
	(_dbus_object_tree_list_registered_and_unlock): new function

2003-09-12  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gidl.h: add common base class for all the foo_info
	types

        * tools/dbus-viewer.c: add GTK-based introspection UI thingy
	similar to kdcop

	* test/Makefile.am: try test srcdir -ef . in addition to test
	srcdir = ., one of them should work (yeah lame)

        * glib/Makefile.am: build the "idl" parser stuff as a convenience
	library

	* glib/dbus-gparser.h: make description_load routines return
	NodeInfo* not Parser*

	* Makefile.am (SUBDIRS): build test dir after all library dirs

	* configure.in: add GTK+ detection

2003-09-07  Havoc Pennington  <hp@pobox.com>

	* Make Doxygen contented.

2003-09-07  Havoc Pennington  <hp@pobox.com>

	* doc/dbus-specification.sgml: more updates

2003-09-06  Havoc Pennington  <hp@pobox.com>

	* doc/dbus-specification.sgml: partial updates

	* bus/dbus-daemon-1.1.in: fix the config file docs for the
	zillionth time; hopefully I edited the right file this time.

	* bus/config-parser.c (append_rule_from_element): support
	send_type, send_path, receive_type, receive_path

	* bus/policy.c: add message type and path to the list of things
	that can be "firewalled"

2003-09-06  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-connection.c (dbus_connection_register_fallback): add this
	(dbus_connection_register_object_path): make this not handle
	messages to paths below the given path

2003-09-03  Havoc Pennington  <hp@pobox.com>

	* test/glib/Makefile.am: add this with random glib-linked test
	programs

	* glib/Makefile.am: remove the random test programs from here,
	leave only the unit tests

	* glib/dbus-gobject.c (_dbus_gobject_test): add test for
	uscore/javacaps conversion, and fix
	(get_object_property, set_object_property): change to .NET
	convention for mapping props to methods, set_FooBar/get_FooBar,
	since one language has such a convention we may as well copy it.
	Plus real methods in either getFooBar or get_foo_bar style won't
	collide with this convention.

2003-09-01  Havoc Pennington  <hp@pobox.com>

	* glib/dbus-gparser.c: implement

	* glib/dbus-gobject.c: start implementing skeletons support

	* configure.in: when disabling checks/assert, also define
	G_DISABLE_ASSERT and G_DISABLE_CHECKS

2003-09-01  Havoc Pennington  <hp@pobox.com>

	* glib/Makefile.am: rearrange a bunch of files and get "make
	check" framework set up

2003-08-31  Havoc Pennington  <hp@pobox.com>

	* fix build with --disable-tests

2003-08-30  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-connection.c: purge DBusMessageHandler

	* dbus/dbus-message-handler.c: remove DBusMessageHandler, just
	use callbacks everywhere

2003-08-30  Havoc Pennington  <hp@pobox.com>

	* test/data/valid-config-files/system.d/test.conf: change to
	root for the user so warnings don't get printed

	* dbus/dbus-message.c: add dbus_message_get_path,
	dbus_message_set_path

	* dbus/dbus-object-tree.c (do_test_dispatch): add test of
	dispatching to a path

	* dbus/dbus-string.c (_dbus_string_validate_path): add

	* dbus/dbus-marshal.c (_dbus_demarshal_object_path): implement
	(_dbus_marshal_object_path): implement

	* dbus/dbus-protocol.h (DBUS_HEADER_FIELD_PATH): new header field
	to contain the path to the target object
	(DBUS_HEADER_FIELD_SENDER_SERVICE): rename
	DBUS_HEADER_FIELD_SENDER to explicitly say it's the sender service

2003-08-30  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-tree.c: write tests and fix the discovered bugs

2003-08-29  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-tree.c: modify to allow overlapping paths to be
	registered
	(struct DBusObjectSubtree): shrink this
	a lot, since we may have a lot of them
	(_dbus_object_tree_free_all_unlocked): implement
	(_dbus_object_tree_dispatch_and_unlock): implement

2003-08-29  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-internals.h: fix _DBUS_N_GLOBAL_LOCKS

2003-08-28  Havoc Pennington  <hp@pobox.com>

	purge DBusObjectID

	* dbus/dbus-connection.c: port to no ObjectID, create a
	DBusObjectTree, rename ObjectTree to ObjectPath in public API

	* dbus/dbus-connection.h (struct DBusObjectTreeVTable): delete
	everything except UnregisterFunction and MessageFunction

	* dbus/dbus-marshal.c: port away from DBusObjectID,
	add DBUS_TYPE_OBJECT_PATH

	* dbus/dbus-object-registry.[hc], dbus/dbus-object.[hc],
	dbus/dbus-objectid.[hc]: remove these, we are moving to
	path-based object IDs

2003-08-25  Havoc Pennington  <hp@pobox.com>

        Just noticed that dbus_message_test is hosed, I wonder when I
	broke that. I thought make check was passing earlier...

	* dbus/dbus-object-tree.c: add new "object tree" to match DCOP
	container tree, will replace most of dbus-object-registry

	* dbus/dbus-string.c (_dbus_string_append_printf_valist): fix C99
	screwup

2003-08-19  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-message.c (decode_string_field): support FIELD_SENDER
	(dbus_message_is_error): fix this function

	* bus/dbus-daemon-1.1: clarify logic on when <deny>/<allow> rules
	match

	* bus/policy.c (bus_client_policy_check_can_receive): fix code to
	reflect clarified man page
	(bus_client_policy_check_can_send): ditto

	* bus/session.conf.in: fixup

	* bus/system.conf.in: fixup

2003-08-18  Havoc Pennington  <hp@redhat.com>

	* dbus/dbus-hash.c (_dbus_hash_table_insert_two_strings): fix

	* dbus/dbus-message.c (_dbus_message_loader_queue_messages): fix
	dumb bug created earlier (wrong order of args to
	decode_header_data())

	* tools/dbus-send.c: port

	* tools/dbus-print-message.c (print_message): port

        * test/data/*messages: port all messages over

        * dbus/dbus-message-builder.c: support including
	message type

        * bus/driver.c: port over

	* bus/dispatch.c: port over to new stuff

	* dbus/dbus-connection.c (_dbus_connection_new_for_transport):
	rename disconnect signal to "Disconnected"

2003-08-17  Havoc Pennington  <hp@pobox.com>

	This doesn't compile yet, but syncing up so I can hack on it from
	work. What are branches for if not broken code? ;-)

	* dbus/dbus-protocol.h: remove DBUS_HEADER_FIELD_NAME, add
	DBUS_HEADER_FIELD_INTERFACE, DBUS_HEADER_FIELD_MEMBER,
	DBUS_HEADER_FIELD_ERROR_NAME

	* dbus/dbus-hash.c: Introduce DBUS_HASH_TWO_STRINGS as hack to use
	for the interface+member pairs
	(string_hash): change to use g_str_hash algorithm
	(find_direct_function, find_string_function): refactor these to
	share most code.

	* dbus/dbus-message.c: port all of this over to support
	interface/member fields instead of name field

	* dbus/dbus-object-registry.c: port over

	* dbus/dbus-string.c (_dbus_string_validate_interface): rename
	from _dbus_string_validate_name

	* bus/dbus-daemon-1.1: change file format for the
	<deny>/<allow> stuff to match new message naming scheme

	* bus/policy.c: port over

	* bus/config-parser.c: parse new format

2003-08-16  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-registry.c (add_and_remove_objects): remove
	broken assertion

	* glib/dbus-gproxy.c: some hacking

2003-08-15  Havoc Pennington  <hp@redhat.com>

	* dbus/dbus-pending-call.c (dbus_pending_call_block): implement

	* dbus/dbus-connection.c
	(dbus_connection_send_with_reply_and_block): factor out internals;
	change to convert any error replies to DBusError instead of
	returning them as a message

2003-08-15  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-connection.c,
	dbus/dbus-pending-call.c: Finish the pending call stuff

2003-08-14  Havoc Pennington  <hp@redhat.com>

	* dbus/dbus-pending-call.c: start on new object that will replace
	DBusMessageHandler and ReplyHandlerData for tracking outstanding
	replies

	* dbus/dbus-gproxy.c: start on proxy object used to communicate
	with remote interfaces

	* dbus/dbus-gidl.c: do the boring boilerplate in here

2003-08-12  Havoc Pennington  <hp@pobox.com>

	* bus/dispatch.c (bus_dispatch): make this return proper
	DBusHandlerResult to avoid DBUS_ERROR_UNKNOWN_METHOD

	* dbus/dbus-errors.c (dbus_set_error): use
	_dbus_string_append_printf_valist

	* dbus/dbus-string.c (_dbus_string_append_printf_valist)
	(_dbus_string_append_printf): new

	* dbus/dbus-errors.h (DBUS_ERROR_UNKNOWN_MESSAGE): change to
	UNKNOWN_METHOD

	* dbus/dbus-connection.c (dbus_connection_dispatch): handle
	DBUS_HANDLER_RESULT_NEED_MEMORY; send default error reply if a
	message is unhandled.

2003-08-11  Havoc Pennington  <hp@pobox.com>

	* bus/test.c (client_disconnect_handler): change to return
	HANDLED (would have been REMOVE_MESSAGE)

	* dbus/dbus-object.h (enum DBusHandlerResult): rename to
	HANDLED/NOT_YET_HANDLED instead of
	REMOVE_MESSAGE/ALLOW_MORE_HANDLERS to make it clearer how it
	should be used.

2003-08-10  Havoc Pennington  <hp@pobox.com>

	* tools/dbus-send.c (main): add --type argument, for now
	supporting only method_call and signal types.

	* tools/dbus-print-message.c: print message type

	* dbus/dbus-connection.c (_dbus_connection_new_for_transport):
	init connection->objects

	* doc/dbus-specification.sgml: fix sgml

	* bus/*.c: port over to object-instance API changes

	* test/test-service.c: ditto

	* dbus/dbus-message.c (dbus_message_create_header): allow #NULL
	name, we will have to fix up the rest of the code to also handle
	this
	(dbus_message_new): generic message-creation call
	(set_string_field): allow appending name field

2003-08-06  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-registry.c: implement signal connection
	and dispatch

	* dbus/dbus-connection.c (_dbus_connection_unref_unlocked): new

	* dbus/dbus-internals.c (_dbus_memdup): new function

2003-08-02  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-message.c (dbus_message_get_no_reply)
	(dbus_message_set_no_reply): add these and remove
	set_is_error/get_is_error

	* dbus/dbus-protocol.h, doc/dbus-specification.sgml:
	remove the ERROR flag, since there's now an ERROR type

2003-08-01  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-registry.c (_dbus_object_registry_handle_and_unlock):
	implement

	* dbus/dbus-message.c (dbus_message_get_type): new function

	* doc/dbus-specification.sgml: add "type" byte to messages

2003-08-01  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-protocol.h (DBUS_MESSAGE_TYPE_*): introduce
	a message type enum to distinguish kinds of message
	(DBUS_HEADER_FLAG_NO_REPLY_EXPECTED): flag for a message
	that need not be replied to

2003-08-01  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-marshal.c: adapt to DBusObjectID changes
	(unpack_8_octets): fix no-64-bit-int bug

	* dbus/dbus-object-registry.c (validate_id): validate the
	connection ID bits, not just the instance ID.

	* dbus/dbus-connection.c (_dbus_connection_init_id): initialize
	the connection-global 33 bits of the object ID

	* dbus/dbus-object-registry.c (info_from_entry): fill in
	object ID in the new way

	* dbus/dbus-objectid.h: rather than high/low bits, specifically
	define server/client/instance bits.

2003-07-30  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-connection.c (dbus_connection_register_object): fix
	build

2003-07-13  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object.h (struct DBusObjectVTable): add padding
	fields to DBusObjectVTable and DBusObjectInfo

2003-07-12  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object-registry.c: implement unit test,
	fix bugs discovered in process

	* dbus/dbus-connection.c: remove handler_table and
	register_handler(), add DBusObjectRegistry usage

	* dbus/dbus-objectid.c (dbus_object_id_is_null)
	(dbus_object_id_set_null): new functions

2003-07-08  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object.c: implement some of this

	* dbus/dbus-object-registry.c
	(_dbus_object_registry_add_and_unlock): fill in the object_id out
	param
	(_dbus_object_registry_new): handle OOM

2003-07-08  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-object.h: sketch out an API for registering objects
	with a connection, that allows us to use as little as 24 bytes
	per object and lets application code represent an object in
	any conceivable way.

	* dbus/dbus-object-registry.c: implement the hard bits of the
	DBusConnection aspect of object API. Not yet wired up.

2003-07-06  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-marshal.c (_dbus_marshal_set_object_id): new function
	(_dbus_marshal_object_id): new
	(_dbus_demarshal_object_id): new
	(_dbus_marshal_get_arg_end_pos): support object ID type, and
	consolidate identical switch cases. Don't conditionalize handling
	of DBUS_TYPE_UINT64, need to handle the type always.
	(_dbus_marshal_validate_arg): consolidate identical cases, and
	handle DBUS_TYPE_OBJECT_ID

	* dbus/dbus-objectid.c: new file with DBusObjectID data type.

	* dbus/dbus-protocol.h: add DBUS_TYPE_OBJECT_ID

2003-09-28  Havoc Pennington  <hp@pobox.com>

	* real 0.13 release

2003-09-28  Havoc Pennington  <hp@pobox.com>

	* doc/Makefile.am (dbus-specification.html): testing a funky hack
	to work with Debian db2html

2003-09-28  Havoc Pennington  <hp@pobox.com>

	* configure.in: 0.13

	* doc/Makefile.am (dbus-test-plan.html): accept nonexistence of
	stylesheet-images for benefit of Debian

	Change back to using filesystem-linked sockets for the system
	bus, so only root can create the default system bus address.

	* bus/system.conf.in: change to use
	DBUS_SYSTEM_BUS_DEFAULT_ADDRESS

	* dbus/Makefile.am (INCLUDES): remove DBUS_SYSTEM_BUS_PATH define
	from here.

	* configure.in: define DBUS_SYSTEM_BUS_DEFAULT_ADDRESS
	here, and AC_DEFINE DBUS_SYSTEM_PATH

2003-08-09  Anders Carlsson  <andersca@codefactory.se>

	* doc/TODO:
	* doc/busconfig.dtd:
	Add busconfig DTD.

2003-08-09  Anders Carlsson  <andersca@codefactory.se>

	* doc/dbus-specification.sgml:
	Add activation reply values.

2003-08-05  Havoc Pennington  <hp@redhat.com>

	* configure.in: 0.12

2003-08-05  Anders Carlsson  <andersca@codefactory.se>

	* glib/dbus-gmain.c: (watch_fd_new), (watch_fd_ref),
	(watch_fd_unref), (dbus_gsource_check), (dbus_gsource_dispatch),
	(add_watch), (remove_watch), (create_source):
	Refcount fds, fixes some reentrancy issues.

2003-07-30  Havoc Pennington  <hp@redhat.com>

	* dbus/dbus-bus.c (init_connections_unlocked): fix default system
	bus address to be abstract if we have abstract sockets

	* NEWS: update

2003-07-28  Havoc Pennington  <hp@redhat.com>

	* bus/messagebus.in: fix to avoid processname/servicename
	confusion, from Michael Kearey
	https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=100965

2003-07-23  Havoc Pennington  <hp@pobox.com>

	* dbus/dbus-message.c (dbus_message_iter_get_named):
	fix from Andy Hanton to remove broken "+1"

2003-07-16  Havoc Pennington  <hp@pobox.com>

	* tools/dbus-launch.c (babysit): close stdout/stderr in the
	babysitter process, as suggested by Thomas Leonard, so
	an "eval `dbus-launch --exit-with-session`" will actually
	return

2003-07-16  Havoc Pennington  <hp@pobox.com>

	* configure.in: print out EXPANDED_* variables in the summary at
	the end; clean up the code that computes EXPANDED_ variables and
	get the ones using exec_prefix right. Should make things work
	when you build without --prefix

1 files changed, 1481 insertions, 0 deletions

diff --git a/dbus/dbus-object-tree.c b/dbus/dbus-object-tree.c
new file mode 100644
index 00000000..07d3ae59
--- /dev/null
+++ b/dbus/dbus-object-tree.c
@@ -0,0 +1,1481 @@
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-object-tree.c  DBusObjectTree (internals of DBusConnection)
+ *
+ * Copyright (C) 2003  Red Hat Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+#include "dbus-object-tree.h"
+#include "dbus-connection-internal.h"
+#include "dbus-internals.h"
+#include "dbus-hash.h"
+#include "dbus-protocol.h"
+#include "dbus-string.h"
+#include <string.h>
+#include <stdlib.h>
+
+/**
+ * @defgroup DBusObjectTree A hierarchy of objects with container-contained relationship
+ * @ingroup  DBusInternals
+ * @brief DBusObjectTree is used by DBusConnection to track the object tree
+ *
+ * Types and functions related to DBusObjectTree. These
+ * are all library-internal.
+ *
+ * @{
+ */
+
+/** Subnode of the object hierarchy */
+typedef struct DBusObjectSubtree DBusObjectSubtree;
+
+static DBusObjectSubtree* _dbus_object_subtree_new   (const char                  *name,
+                                                      const DBusObjectPathVTable  *vtable,
+                                                      void                        *user_data);
+static void               _dbus_object_subtree_ref   (DBusObjectSubtree           *subtree);
+static void               _dbus_object_subtree_unref (DBusObjectSubtree           *subtree);
+
+/**
+ * Internals of DBusObjectTree
+ */
+struct DBusObjectTree
+{
+  int                 refcount;   /**< Reference count */
+  DBusConnection     *connection; /**< Connection this tree belongs to */
+
+  DBusObjectSubtree  *root;       /**< Root of the tree ("/" node) */
+};
+
+/**
+ * Struct representing a single registered subtree handler, or node
+ * that's a parent of a registered subtree handler. If
+ * message_function != NULL there's actually a handler at this node.
+ */
+struct DBusObjectSubtree
+{
+  DBusAtomic                         refcount;            /**< Reference count */
+  DBusObjectSubtree                 *parent;              /**< Parent node */
+  DBusObjectPathUnregisterFunction   unregister_function; /**< Function to call on unregister */
+  DBusObjectPathMessageFunction      message_function;    /**< Function to handle messages */
+  void                              *user_data;           /**< Data for functions */
+  DBusObjectSubtree                **subtrees;            /**< Child nodes */
+  int                                n_subtrees;          /**< Number of child nodes */
+  unsigned int                       subtrees_sorted : 1; /**< Whether children are sorted */
+  unsigned int                       invoke_as_fallback : 1; /**< Whether to invoke message_function when child nodes don't handle the message */
+  char                               name[1]; /**< Allocated as large as necessary */
+};
+
+/**
+ * Creates a new object tree, representing a mapping from paths
+ * to handler vtables.
+ *
+ * @param connection the connection this tree belongs to
+ * @returns the new tree or #NULL if no memory
+ */
+DBusObjectTree*
+_dbus_object_tree_new (DBusConnection *connection)
+{
+  DBusObjectTree *tree;
+
+  /* the connection passed in here isn't fully constructed,
+   * so don't do anything more than store a pointer to
+   * it
+   */
+
+  tree = dbus_new0 (DBusObjectTree, 1);
+  if (tree == NULL)
+    goto oom;
+
+  tree->refcount = 1;
+  tree->connection = connection;
+  tree->root = _dbus_object_subtree_new ("/", NULL, NULL);
+  if (tree->root == NULL)
+    goto oom;
+  tree->root->invoke_as_fallback = TRUE;
+  
+  return tree;
+
+ oom:
+  if (tree)
+    {
+      dbus_free (tree);
+    }
+
+  return NULL;
+}
+
+/**
+ * Increment the reference count
+ * @param tree the object tree
+ */
+void
+_dbus_object_tree_ref (DBusObjectTree *tree)
+{
+  _dbus_assert (tree->refcount > 0);
+
+  tree->refcount += 1;
+}
+
+/**
+ * Decrement the reference count
+ * @param tree the object tree
+ */
+void
+_dbus_object_tree_unref (DBusObjectTree *tree)
+{
+  _dbus_assert (tree->refcount > 0);
+
+  tree->refcount -= 1;
+
+  if (tree->refcount == 0)
+    {
+      _dbus_object_tree_free_all_unlocked (tree);
+
+      dbus_free (tree);
+    }
+}
+
+static int
+subtree_cmp (DBusObjectSubtree *subtree_a,
+             DBusObjectSubtree *subtree_b)
+{
+  return strcmp (subtree_a->name, subtree_b->name);
+}
+
+static int
+subtree_qsort_cmp (const void *a,
+                   const void *b)
+{
+  DBusObjectSubtree **subtree_a_p = (void*) a;
+  DBusObjectSubtree **subtree_b_p = (void*) b;
+
+  return subtree_cmp (*subtree_a_p, *subtree_b_p);
+}
+
+static void
+ensure_sorted (DBusObjectSubtree *subtree)
+{
+  if (subtree->subtrees && !subtree->subtrees_sorted)
+    {
+      qsort (subtree->subtrees,
+             subtree->n_subtrees,
+             sizeof (DBusObjectSubtree*),
+             subtree_qsort_cmp);
+      subtree->subtrees_sorted = TRUE;
+    }
+}
+
+/** Set to 1 to get a bunch of debug spew about finding the
+ * subtree nodes
+ */
+#define VERBOSE_FIND 0
+
+static DBusObjectSubtree*
+find_subtree_recurse (DBusObjectSubtree  *subtree,
+                      const char        **path,
+                      dbus_bool_t         return_deepest_match,
+                      dbus_bool_t         create_if_not_found,
+                      int                *index_in_parent)
+{
+  int i;
+
+  _dbus_assert (!(return_deepest_match && create_if_not_found));
+
+  if (path[0] == NULL)
+    {
+#if VERBOSE_FIND
+      _dbus_verbose ("  path exhausted, returning %s\n",
+                     subtree->name);
+#endif
+      return subtree;
+    }
+
+#if VERBOSE_FIND
+  _dbus_verbose ("  searching children of %s for %s\n",
+                 subtree->name, path[0]);
+#endif
+  
+  ensure_sorted (subtree);
+
+  /* FIXME we should do a binary search here instead
+   * of O(n)
+   */
+
+  i = 0;
+  while (i < subtree->n_subtrees)
+    {
+      int v;
+
+      v = strcmp (path[0], subtree->subtrees[i]->name);
+
+#if VERBOSE_FIND
+      _dbus_verbose ("  %s cmp %s = %d\n",
+                     path[0], subtree->subtrees[i]->name,
+                     v);
+#endif
+      
+      if (v == 0)
+        {
+          if (index_in_parent)
+            {
+#if VERBOSE_FIND
+              _dbus_verbose ("  storing parent index %d\n", i);
+#endif
+              *index_in_parent = i;
+            }
+
+          if (return_deepest_match)
+            {
+              DBusObjectSubtree *next;
+
+              next = find_subtree_recurse (subtree->subtrees[i],
+                                           &path[1], return_deepest_match,
+                                           create_if_not_found, index_in_parent);
+              if (next == NULL &&
+                  subtree->invoke_as_fallback)
+                {
+#if VERBOSE_FIND
+                  _dbus_verbose ("  no deeper match found, returning %s\n",
+                                 subtree->name);
+#endif
+                  return subtree;
+                }
+              else
+                return next;
+            }
+          else
+            return find_subtree_recurse (subtree->subtrees[i],
+                                         &path[1], return_deepest_match,
+                                         create_if_not_found, index_in_parent);
+        }
+      else if (v < 0)
+        {
+          goto not_found;
+        }
+
+      ++i;
+    }
+
+ not_found:
+#if VERBOSE_FIND
+  _dbus_verbose ("  no match found, current tree %s, create_if_not_found = %d\n",
+                 subtree->name, create_if_not_found);
+#endif
+  
+  if (create_if_not_found)
+    {
+      DBusObjectSubtree* child;
+      DBusObjectSubtree **new_subtrees;
+      int new_n_subtrees;
+
+#if VERBOSE_FIND
+      _dbus_verbose ("  creating subtree %s\n",
+                     path[0]);
+#endif
+      
+      child = _dbus_object_subtree_new (path[0],
+                                        NULL, NULL);
+      if (child == NULL)
+        return NULL;
+
+      /* FIXME we should do the "double alloc each time" standard thing */
+      new_n_subtrees = subtree->n_subtrees + 1;
+      new_subtrees = dbus_realloc (subtree->subtrees,
+                                   new_n_subtrees * sizeof (DBusObjectSubtree*));
+      if (new_subtrees == NULL)
+        {
+          child->unregister_function = NULL;
+          child->message_function = NULL;
+          _dbus_object_subtree_unref (child);
+          return FALSE;
+        }
+
+      new_subtrees[subtree->n_subtrees] = child;
+      if (index_in_parent)
+        *index_in_parent = subtree->n_subtrees;
+      subtree->subtrees_sorted = FALSE;
+      subtree->n_subtrees = new_n_subtrees;
+      subtree->subtrees = new_subtrees;
+
+      child->parent = subtree;
+
+      return find_subtree_recurse (child,
+                                   &path[1], return_deepest_match,
+                                   create_if_not_found, index_in_parent);
+    }
+  else
+    return (return_deepest_match && subtree->invoke_as_fallback) ? subtree : NULL;
+}
+
+static DBusObjectSubtree*
+find_subtree (DBusObjectTree *tree,
+              const char    **path,
+              int            *index_in_parent)
+{
+  DBusObjectSubtree *subtree;
+
+#if VERBOSE_FIND
+  _dbus_verbose ("Looking for exact registered subtree\n");
+#endif
+  
+  subtree = find_subtree_recurse (tree->root, path, FALSE, FALSE, index_in_parent);
+
+  if (subtree && subtree->message_function == NULL)
+    return NULL;
+  else
+    return subtree;
+}
+
+static DBusObjectSubtree*
+find_handler (DBusObjectTree *tree,
+              const char    **path)
+{
+#if VERBOSE_FIND
+  _dbus_verbose ("Looking for deepest handler\n");
+#endif
+  return find_subtree_recurse (tree->root, path, TRUE, FALSE, NULL);
+}
+
+static DBusObjectSubtree*
+ensure_subtree (DBusObjectTree *tree,
+                const char    **path)
+{
+#if VERBOSE_FIND
+  _dbus_verbose ("Ensuring subtree\n");
+#endif
+  return find_subtree_recurse (tree->root, path, FALSE, TRUE, NULL);
+}
+
+/**
+ * Registers a new subtree in the global object tree.
+ *
+ * @param tree the global object tree
+ * @param fallback #TRUE to handle messages to children of this path
+ * @param path NULL-terminated array of path elements giving path to subtree
+ * @param vtable the vtable used to traverse this subtree
+ * @param user_data user data to pass to methods in the vtable
+ * @returns #FALSE if not enough memory
+ */
+dbus_bool_t
+_dbus_object_tree_register (DBusObjectTree              *tree,
+                            dbus_bool_t                  fallback,
+                            const char                 **path,
+                            const DBusObjectPathVTable  *vtable,
+                            void                        *user_data)
+{
+  DBusObjectSubtree  *subtree;
+
+  _dbus_assert (tree != NULL);
+  _dbus_assert (vtable->message_function != NULL);
+  _dbus_assert (path != NULL);
+
+  subtree = ensure_subtree (tree, path);
+  if (subtree == NULL)
+    return FALSE;
+
+#ifndef DBUS_DISABLE_CHECKS
+  if (subtree->message_function != NULL)
+    {
+      _dbus_warn ("A handler is already registered for the path starting with path[0] = \"%s\"\n",
+                  path[0] ? path[0] : "null");
+      return FALSE;
+    }
+#else
+  _dbus_assert (subtree->message_function == NULL);
+#endif
+
+  subtree->message_function = vtable->message_function;
+  subtree->unregister_function = vtable->unregister_function;
+  subtree->user_data = user_data;
+  subtree->invoke_as_fallback = fallback != FALSE;
+  
+  return TRUE;
+}
+
+/**
+ * Unregisters an object subtree that was registered with the
+ * same path.
+ *
+ * @param tree the global object tree
+ * @param path path to the subtree (same as the one passed to _dbus_object_tree_register())
+ */
+void
+_dbus_object_tree_unregister_and_unlock (DBusObjectTree          *tree,
+                                         const char             **path)
+{
+  int i;
+  DBusObjectSubtree *subtree;
+  DBusObjectPathUnregisterFunction unregister_function;
+  void *user_data;
+  DBusConnection *connection;
+
+  _dbus_assert (path != NULL);
+
+  subtree = find_subtree (tree, path, &i);
+
+#ifndef DBUS_DISABLE_CHECKS
+  if (subtree == NULL)
+    {
+      _dbus_warn ("Attempted to unregister path (path[0] = %s path[1] = %s) which isn't registered\n",
+                  path[0] ? path[0] : "null",
+                  path[1] ? path[1] : "null");
+      return;
+    }
+#else
+  _dbus_assert (subtree != NULL);
+#endif
+
+  _dbus_assert (subtree->parent == NULL ||
+                (i >= 0 && subtree->parent->subtrees[i] == subtree));
+
+  subtree->message_function = NULL;
+
+  unregister_function = subtree->unregister_function;
+  user_data = subtree->user_data;
+
+  subtree->unregister_function = NULL;
+  subtree->user_data = NULL;
+
+  /* If we have no subtrees of our own, remove from
+   * our parent (FIXME could also be more aggressive
+   * and remove our parent if it becomes empty)
+   */
+  if (subtree->parent && subtree->n_subtrees == 0)
+    {
+      /* assumes a 0-byte memmove is OK */
+      memmove (&subtree->parent->subtrees[i],
+               &subtree->parent->subtrees[i+1],
+               (subtree->parent->n_subtrees - i - 1) *
+               sizeof (subtree->parent->subtrees[0]));
+      subtree->parent->n_subtrees -= 1;
+
+      subtree->parent = NULL;
+
+      _dbus_object_subtree_unref (subtree);
+    }
+  subtree = NULL;
+
+  connection = tree->connection;
+
+  /* Unlock and call application code */
+#ifdef DBUS_BUILD_TESTS
+  if (connection)
+#endif
+    {
+      _dbus_connection_ref_unlocked (connection);
+      _dbus_connection_unlock (connection);
+    }
+
+  if (unregister_function)
+    (* unregister_function) (connection, user_data);
+
+#ifdef DBUS_BUILD_TESTS
+  if (connection)
+#endif
+    dbus_connection_unref (connection);
+}
+
+static void
+free_subtree_recurse (DBusConnection    *connection,
+                      DBusObjectSubtree *subtree)
+{
+  /* Delete them from the end, for slightly
+   * more robustness against odd reentrancy.
+   */
+  while (subtree->n_subtrees > 0)
+    {
+      DBusObjectSubtree *child;
+
+      child = subtree->subtrees[subtree->n_subtrees - 1];
+      subtree->subtrees[subtree->n_subtrees - 1] = NULL;
+      subtree->n_subtrees -= 1;
+      child->parent = NULL;
+
+      free_subtree_recurse (connection, child);
+    }
+
+  /* Call application code */
+  if (subtree->unregister_function)
+    {
+      (* subtree->unregister_function) (connection,
+                                        subtree->user_data);
+      subtree->message_function = NULL;
+      subtree->unregister_function = NULL;
+      subtree->user_data = NULL;
+    }
+
+  /* Now free ourselves */
+  _dbus_object_subtree_unref (subtree);
+}
+
+/**
+ * Free all the handlers in the tree. Lock on tree's connection
+ * must not be held.
+ *
+ * @param tree the object tree
+ */
+void
+_dbus_object_tree_free_all_unlocked (DBusObjectTree *tree)
+{
+  if (tree->root)
+    free_subtree_recurse (tree->connection,
+                          tree->root);
+  tree->root = NULL;
+}
+
+static dbus_bool_t
+_dbus_object_tree_list_registered_unlocked (DBusObjectTree *tree,
+                                            const char    **parent_path,
+                                            char         ***child_entries)
+{
+  DBusObjectSubtree *subtree;
+  char **retval;
+  
+  _dbus_assert (parent_path != NULL);
+  _dbus_assert (child_entries != NULL);
+
+  *child_entries = NULL;
+  
+  subtree = find_subtree (tree, parent_path, NULL);
+  if (subtree == NULL)
+    {
+      retval = dbus_new0 (char *, 1);
+      if (retval == NULL)
+        goto out;
+    }
+  else
+    {
+      int i;
+      retval = dbus_new0 (char*, subtree->n_subtrees + 1);
+      if (retval == NULL)
+        goto out;
+      i = 0;
+      while (i < subtree->n_subtrees)
+        {
+          retval[i] = _dbus_strdup (subtree->subtrees[i]->name);
+          if (retval[i] == NULL)
+            {
+              dbus_free_string_array (retval);
+              retval = NULL;
+              goto out;
+            }
+          ++i;
+        }
+    }
+
+ out:
+    
+  *child_entries = retval;
+  return retval != NULL;
+}
+
+static DBusHandlerResult
+handle_default_introspect_unlocked (DBusObjectTree          *tree,
+                                    DBusMessage             *message,
+                                    const char             **path)
+{
+  DBusString xml;
+  DBusHandlerResult result;
+  char **children;
+  int i;
+
+  if (!dbus_message_is_method_call (message,
+                                    DBUS_INTERFACE_ORG_FREEDESKTOP_INTROSPECTABLE,
+                                    "Introspect"))
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+  
+  if (!_dbus_string_init (&xml))
+    return DBUS_HANDLER_RESULT_NEED_MEMORY;
+
+  result = DBUS_HANDLER_RESULT_NEED_MEMORY;
+
+  children = NULL;
+  if (!_dbus_object_tree_list_registered_unlocked (tree, path, &children))
+    goto out;
+
+  if (!_dbus_string_append (&xml, "<node>\n"))
+    goto out;
+
+  i = 0;
+  while (children[i] != NULL)
+    {
+      if (!_dbus_string_append_printf (&xml, "  <node name=\"%s\"/>\n",
+                                       children[i]))
+        goto out;
+
+      ++i;
+    }
+
+  if (!_dbus_string_append (&xml, "</node>\n"))
+    goto out;
+  
+  result = DBUS_HANDLER_RESULT_HANDLED;
+  
+ out:
+  _dbus_string_free (&xml);
+  dbus_free_string_array (children);
+  
+  return result;
+}
+
+/**
+ * Tries to dispatch a message by directing it to handler for the
+ * object path listed in the message header, if any. Messages are
+ * dispatched first to the registered handler that matches the largest
+ * number of path elements; that is, message to /foo/bar/baz would go
+ * to the handler for /foo/bar before the one for /foo.
+ *
+ * @todo thread problems
+ *
+ * @param tree the global object tree
+ * @param message the message to dispatch
+ * @returns whether message was handled successfully
+ */
+DBusHandlerResult
+_dbus_object_tree_dispatch_and_unlock (DBusObjectTree          *tree,
+                                       DBusMessage             *message)
+{
+  char **path;
+  DBusList *list;
+  DBusList *link;
+  DBusHandlerResult result;
+  DBusObjectSubtree *subtree;
+  
+#if 0
+  _dbus_verbose ("Dispatch of message by object path\n");
+#endif
+  
+  path = NULL;
+  if (!dbus_message_get_path_decomposed (message, &path))
+    {
+#ifdef DBUS_BUILD_TESTS
+      if (tree->connection)
+#endif
+        _dbus_connection_unlock (tree->connection);
+      
+      _dbus_verbose ("No memory to get decomposed path\n");
+
+      return DBUS_HANDLER_RESULT_NEED_MEMORY;
+    }
+
+  if (path == NULL)
+    {
+#ifdef DBUS_BUILD_TESTS
+      if (tree->connection)
+#endif
+        _dbus_connection_unlock (tree->connection);
+      
+      _dbus_verbose ("No path field in message\n");
+      return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+    }
+  
+  /* Find the deepest path that covers the path in the message */
+  subtree = find_handler (tree, (const char**) path);
+  
+  /* Build a list of all paths that cover the path in the message */
+
+  list = NULL;
+
+  while (subtree != NULL)
+    {
+      if (subtree->message_function != NULL)
+        {
+          _dbus_object_subtree_ref (subtree);
+
+          /* run deepest paths first */
+          if (!_dbus_list_append (&list, subtree))
+            {
+              result = DBUS_HANDLER_RESULT_NEED_MEMORY;
+              _dbus_object_subtree_unref (subtree);
+              goto free_and_return;
+            }
+        }
+
+      subtree = subtree->parent;
+    }
+
+  _dbus_verbose ("%d handlers in the path tree for this message\n",
+                 _dbus_list_get_length (&list));
+
+  /* Invoke each handler in the list */
+
+  result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+  link = _dbus_list_get_first_link (&list);
+  while (link != NULL)
+    {
+      DBusList *next = _dbus_list_get_next_link (&list, link);
+      subtree = link->data;
+
+      /* message_function is NULL if we're unregistered
+       * due to reentrancy
+       */
+      if (subtree->message_function)
+        {
+          DBusObjectPathMessageFunction message_function;
+          void *user_data;
+
+          message_function = subtree->message_function;
+          user_data = subtree->user_data;
+
+#if 0
+          _dbus_verbose ("  (invoking a handler)\n");
+#endif
+          
+#ifdef DBUS_BUILD_TESTS
+          if (tree->connection)
+#endif
+            _dbus_connection_unlock (tree->connection);
+
+          /* FIXME you could unregister the subtree in another thread
+           * before we invoke the callback, and I can't figure out a
+           * good way to solve this.
+           */
+
+          result = (* message_function) (tree->connection,
+                                         message,
+                                         user_data);
+
+#ifdef DBUS_BUILD_TESTS
+          if (tree->connection)
+#endif
+            _dbus_connection_lock (tree->connection);
+
+          if (result != DBUS_HANDLER_RESULT_NOT_YET_HANDLED)
+            goto free_and_return;
+        }
+
+      link = next;
+    }
+
+ free_and_return:
+
+  if (result == DBUS_HANDLER_RESULT_NOT_YET_HANDLED)
+    {
+      /* This hardcoded default handler does a minimal Introspect()
+       */
+      result = handle_default_introspect_unlocked (tree, message,
+                                                   (const char**) path);
+    }
+
+#ifdef DBUS_BUILD_TESTS
+  if (tree->connection)
+#endif
+    _dbus_connection_unlock (tree->connection);
+  
+  while (list != NULL)
+    {
+      link = _dbus_list_get_first_link (&list);
+      _dbus_object_subtree_unref (link->data);
+      _dbus_list_remove_link (&list, link);
+    }
+  
+  dbus_free_string_array (path);
+
+  return result;
+}
+
+/**
+ * Allocates a subtree object.
+ *
+ * @param name name to duplicate.
+ * @returns newly-allocated subtree
+ */
+static DBusObjectSubtree*
+allocate_subtree_object (const char *name)
+{
+  int len;
+  DBusObjectSubtree *subtree;
+  const size_t front_padding = _DBUS_STRUCT_OFFSET (DBusObjectSubtree, name);
+
+  _dbus_assert (name != NULL);
+
+  len = strlen (name);
+
+  subtree = dbus_malloc (front_padding + (len + 1));
+
+  if (subtree == NULL)
+    return NULL;
+
+  memcpy (subtree->name, name, len + 1);
+
+  return subtree;
+}
+
+static DBusObjectSubtree*
+_dbus_object_subtree_new (const char                  *name,
+                          const DBusObjectPathVTable  *vtable,
+                          void                        *user_data)
+{
+  DBusObjectSubtree *subtree;
+
+  subtree = allocate_subtree_object (name);
+  if (subtree == NULL)
+    goto oom;
+
+  _dbus_assert (name != NULL);
+
+  subtree->parent = NULL;
+
+  if (vtable)
+    {
+      subtree->message_function = vtable->message_function;
+      subtree->unregister_function = vtable->unregister_function;
+    }
+  else
+    {
+      subtree->message_function = NULL;
+      subtree->unregister_function = NULL;
+    }
+
+  subtree->user_data = user_data;
+  subtree->refcount.value = 1;
+  subtree->subtrees = NULL;
+  subtree->n_subtrees = 0;
+  subtree->subtrees_sorted = TRUE;
+  
+  return subtree;
+
+ oom:
+  if (subtree)
+    {
+      dbus_free (subtree);
+    }
+
+  return NULL;
+}
+
+static void
+_dbus_object_subtree_ref (DBusObjectSubtree *subtree)
+{
+  _dbus_assert (subtree->refcount.value > 0);
+  _dbus_atomic_inc (&subtree->refcount);
+}
+
+static void
+_dbus_object_subtree_unref (DBusObjectSubtree *subtree)
+{
+  _dbus_assert (subtree->refcount.value > 0);
+
+  if (_dbus_atomic_dec (&subtree->refcount) == 1)
+    {
+      _dbus_assert (subtree->unregister_function == NULL);
+      _dbus_assert (subtree->message_function == NULL);
+
+      dbus_free (subtree->subtrees);
+      dbus_free (subtree);
+    }
+}
+
+/**
+ * Lists the registered fallback handlers and object path handlers at
+ * the given parent_path. The returned array should be freed with
+ * dbus_free_string_array().
+ *
+ * @param connection the connection
+ * @param parent_path the path to list the child handlers of
+ * @param child_entries returns #NULL-terminated array of children
+ * @returns #FALSE if no memory to allocate the child entries
+ */
+dbus_bool_t
+_dbus_object_tree_list_registered_and_unlock (DBusObjectTree *tree,
+                                              const char    **parent_path,
+                                              char         ***child_entries)
+{
+  dbus_bool_t result;
+
+  result = _dbus_object_tree_list_registered_unlocked (tree,
+                                                       parent_path,
+                                                       child_entries);
+  
+#ifdef DBUS_BUILD_TESTS
+  if (tree->connection)
+#endif
+    _dbus_connection_unlock (tree->connection);
+
+  return result;
+}
+     
+/** @} */
+
+#ifdef DBUS_BUILD_TESTS
+#include "dbus-test.h"
+#include <stdio.h>
+
+static char*
+flatten_path (const char **path)
+{
+  DBusString str;
+  int i;
+  char *s;
+
+  if (!_dbus_string_init (&str))
+    return NULL;
+
+  i = 0;
+  while (path[i])
+    {
+      if (!_dbus_string_append_byte (&str, '/'))
+        goto nomem;
+
+      if (!_dbus_string_append (&str, path[i]))
+        goto nomem;
+
+      ++i;
+    }
+
+  if (!_dbus_string_steal_data (&str, &s))
+    goto nomem;
+
+  _dbus_string_free (&str);
+
+  return s;
+
+ nomem:
+  _dbus_string_free (&str);
+  return NULL;
+}
+
+/* Returns TRUE if container is a parent of child
+ */
+static dbus_bool_t
+path_contains (const char **container,
+               const char **child)
+{
+  int i;
+
+  i = 0;
+  while (child[i] != NULL)
+    {
+      int v;
+
+      if (container[i] == NULL)
+        return TRUE; /* container ran out, child continues;
+                      * thus the container is a parent of the
+                      * child.
+                      */
+
+      _dbus_assert (container[i] != NULL);
+      _dbus_assert (child[i] != NULL);
+
+      v = strcmp (container[i], child[i]);
+
+      if (v != 0)
+        return FALSE; /* they overlap until here and then are different,
+                       * not overlapping
+                       */
+
+      ++i;
+    }
+
+  /* Child ran out; if container also did, they are equal;
+   * otherwise, the child is a parent of the container.
+   */
+  if (container[i] == NULL)
+    return TRUE; /* equal is counted as containing */
+  else
+    return FALSE;
+}
+
+static void
+spew_subtree_recurse (DBusObjectSubtree *subtree,
+                      int                indent)
+{
+  int i;
+
+  i = 0;
+  while (i < indent)
+    {
+      _dbus_verbose (" ");
+      ++i;
+    }
+
+  _dbus_verbose ("%s (%d children)\n",
+                 subtree->name, subtree->n_subtrees);
+
+  i = 0;
+  while (i < subtree->n_subtrees)
+    {
+      spew_subtree_recurse (subtree->subtrees[i], indent + 2);
+
+      ++i;
+    }
+}
+
+static void
+spew_tree (DBusObjectTree *tree)
+{
+  spew_subtree_recurse (tree->root, 0);
+}
+
+/**
+ * Callback data used in tests
+ */
+typedef struct
+{
+  const char **path; /**< Path */
+  dbus_bool_t message_handled; /**< Gets set to true if message handler called */
+  dbus_bool_t handler_unregistered; /**< gets set to true if handler is unregistered */
+
+} TreeTestData;
+
+
+static void
+test_unregister_function (DBusConnection  *connection,
+                          void            *user_data)
+{
+  TreeTestData *ttd = user_data;
+
+  ttd->handler_unregistered = TRUE;
+}
+
+static DBusHandlerResult
+test_message_function (DBusConnection  *connection,
+                       DBusMessage     *message,
+                       void            *user_data)
+{
+  TreeTestData *ttd = user_data;
+
+  ttd->message_handled = TRUE;
+
+  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static dbus_bool_t
+do_register (DBusObjectTree *tree,
+             const char    **path,
+             int             i,
+             TreeTestData   *tree_test_data)
+{
+  DBusObjectPathVTable vtable = { test_unregister_function,
+                                  test_message_function, NULL };
+
+  tree_test_data[i].message_handled = FALSE;
+  tree_test_data[i].handler_unregistered = FALSE;
+  tree_test_data[i].path = path;
+
+  if (!_dbus_object_tree_register (tree, TRUE, path,
+                                   &vtable,
+                                   &tree_test_data[i]))
+    return FALSE;
+
+  return TRUE;
+}
+
+static dbus_bool_t
+do_test_dispatch (DBusObjectTree *tree,
+                  const char    **path,
+                  int             i,
+                  TreeTestData   *tree_test_data,
+                  int             n_test_data)
+{
+  DBusMessage *message;
+  int j;
+  DBusHandlerResult result;
+  char *flat;
+
+  message = NULL;
+  
+  flat = flatten_path (path);
+  if (flat == NULL)
+    goto oom;
+
+  message = dbus_message_new_method_call (NULL,
+                                          flat,
+                                          "org.freedesktop.TestInterface",
+                                          "Foo");
+  dbus_free (flat);
+  if (message == NULL)
+    goto oom;
+
+  j = 0;
+  while (j < n_test_data)
+    {
+      tree_test_data[j].message_handled = FALSE;
+      ++j;
+    }
+
+  result = _dbus_object_tree_dispatch_and_unlock (tree, message);
+  if (result == DBUS_HANDLER_RESULT_NEED_MEMORY)
+    goto oom;
+
+  _dbus_assert (tree_test_data[i].message_handled);
+
+  j = 0;
+  while (j < n_test_data)
+    {
+      if (tree_test_data[j].message_handled)
+        _dbus_assert (path_contains (tree_test_data[j].path,
+                                     path));
+      else
+        _dbus_assert (!path_contains (tree_test_data[j].path,
+                                      path));
+
+      ++j;
+    }
+
+  dbus_message_unref (message);
+
+  return TRUE;
+
+ oom:
+  if (message)
+    dbus_message_unref (message);
+  return FALSE;
+}
+
+static dbus_bool_t
+object_tree_test_iteration (void *data)
+{
+  const char *path1[] = { "foo", NULL };
+  const char *path2[] = { "foo", "bar", NULL };
+  const char *path3[] = { "foo", "bar", "baz", NULL };
+  const char *path4[] = { "foo", "bar", "boo", NULL };
+  const char *path5[] = { "blah", NULL };
+  const char *path6[] = { "blah", "boof", NULL };
+  const char *path7[] = { "blah", "boof", "this", "is", "really", "long", NULL };
+  const char *path8[] = { "childless", NULL };
+  DBusObjectTree *tree;
+  TreeTestData tree_test_data[8];
+  int i;
+
+  tree = NULL;
+
+  tree = _dbus_object_tree_new (NULL);
+  if (tree == NULL)
+    goto out;
+
+  if (!do_register (tree, path1, 0, tree_test_data))
+    goto out;
+
+  _dbus_assert (find_subtree (tree, path1, NULL));
+  _dbus_assert (!find_subtree (tree, path2, NULL));
+  _dbus_assert (!find_subtree (tree, path3, NULL));
+  _dbus_assert (!find_subtree (tree, path4, NULL));
+  _dbus_assert (!find_subtree (tree, path5, NULL));
+  _dbus_assert (!find_subtree (tree, path6, NULL));
+  _dbus_assert (!find_subtree (tree, path7, NULL));
+  _dbus_assert (!find_subtree (tree, path8, NULL));
+
+  _dbus_assert (find_handler (tree, path1));
+  _dbus_assert (find_handler (tree, path2));
+  _dbus_assert (find_handler (tree, path3));
+  _dbus_assert (find_handler (tree, path4));
+  _dbus_assert (find_handler (tree, path5) == tree->root);
+  _dbus_assert (find_handler (tree, path6) == tree->root);
+  _dbus_assert (find_handler (tree, path7) == tree->root);
+  _dbus_assert (find_handler (tree, path8) == tree->root);
+
+  if (!do_register (tree, path2, 1, tree_test_data))
+    goto out;
+
+  _dbus_assert (find_subtree (tree, path1, NULL));
+  _dbus_assert (find_subtree (tree, path2, NULL));
+  _dbus_assert (!find_subtree (tree, path3, NULL));
+  _dbus_assert (!find_subtree (tree, path4, NULL));
+  _dbus_assert (!find_subtree (tree, path5, NULL));
+  _dbus_assert (!find_subtree (tree, path6, NULL));
+  _dbus_assert (!find_subtree (tree, path7, NULL));
+  _dbus_assert (!find_subtree (tree, path8, NULL));
+
+  if (!do_register (tree, path3, 2, tree_test_data))
+    goto out;
+
+  _dbus_assert (find_subtree (tree, path1, NULL));
+  _dbus_assert (find_subtree (tree, path2, NULL));
+  _dbus_assert (find_subtree (tree, path3, NULL));
+  _dbus_assert (!find_subtree (tree, path4, NULL));
+  _dbus_assert (!find_subtree (tree, path5, NULL));
+  _dbus_assert (!find_subtree (tree, path6, NULL));
+  _dbus_assert (!find_subtree (tree, path7, NULL));
+  _dbus_assert (!find_subtree (tree, path8, NULL));
+  
+  if (!do_register (tree, path4, 3, tree_test_data))
+    goto out;
+
+  _dbus_assert (find_subtree (tree, path1, NULL));
+  _dbus_assert (find_subtree (tree, path2, NULL));
+  _dbus_assert (find_subtree (tree, path3, NULL));  
+  _dbus_assert (find_subtree (tree, path4, NULL));
+  _dbus_assert (!find_subtree (tree, path5, NULL));
+  _dbus_assert (!find_subtree (tree, path6, NULL));
+  _dbus_assert (!find_subtree (tree, path7, NULL));
+  _dbus_assert (!find_subtree (tree, path8, NULL));
+  
+  if (!do_register (tree, path5, 4, tree_test_data))
+    goto out;
+
+  _dbus_assert (find_subtree (tree, path1, NULL));
+  _dbus_assert (find_subtree (tree, path2, NULL));
+  _dbus_assert (find_subtree (tree, path3, NULL));
+  _dbus_assert (find_subtree (tree, path4, NULL));
+  _dbus_assert (find_subtree (tree, path5, NULL));
+  _dbus_assert (!find_subtree (tree, path6, NULL));
+  _dbus_assert (!find_subtree (tree, path7, NULL));
+  _dbus_assert (!find_subtree (tree, path8, NULL));
+  
+  _dbus_assert (find_handler (tree, path1) != tree->root);
+  _dbus_assert (find_handler (tree, path2) != tree->root);
+  _dbus_assert (find_handler (tree, path3) != tree->root);
+  _dbus_assert (find_handler (tree, path4) != tree->root);
+  _dbus_assert (find_handler (tree, path5) != tree->root);
+  _dbus_assert (find_handler (tree, path6) != tree->root);
+  _dbus_assert (find_handler (tree, path7) != tree->root);
+  _dbus_assert (find_handler (tree, path8) == tree->root);
+
+  if (!do_register (tree, path6, 5, tree_test_data))
+    goto out;
+
+  _dbus_assert (find_subtree (tree, path1, NULL));
+  _dbus_assert (find_subtree (tree, path2, NULL));
+  _dbus_assert (find_subtree (tree, path3, NULL));
+  _dbus_assert (find_subtree (tree, path4, NULL));
+  _dbus_assert (find_subtree (tree, path5, NULL));
+  _dbus_assert (find_subtree (tree, path6, NULL));
+  _dbus_assert (!find_subtree (tree, path7, NULL));
+  _dbus_assert (!find_subtree (tree, path8, NULL));
+
+  if (!do_register (tree, path7, 6, tree_test_data))
+    goto out;
+
+  _dbus_assert (find_subtree (tree, path1, NULL));
+  _dbus_assert (find_subtree (tree, path2, NULL));
+  _dbus_assert (find_subtree (tree, path3, NULL));
+  _dbus_assert (find_subtree (tree, path4, NULL));
+  _dbus_assert (find_subtree (tree, path5, NULL));
+  _dbus_assert (find_subtree (tree, path6, NULL));
+  _dbus_assert (find_subtree (tree, path7, NULL));
+  _dbus_assert (!find_subtree (tree, path8, NULL));
+
+  if (!do_register (tree, path8, 7, tree_test_data))
+    goto out;
+
+  _dbus_assert (find_subtree (tree, path1, NULL));
+  _dbus_assert (find_subtree (tree, path2, NULL));
+  _dbus_assert (find_subtree (tree, path3, NULL));
+  _dbus_assert (find_subtree (tree, path4, NULL));
+  _dbus_assert (find_subtree (tree, path5, NULL));
+  _dbus_assert (find_subtree (tree, path6, NULL));
+  _dbus_assert (find_subtree (tree, path7, NULL));
+  _dbus_assert (find_subtree (tree, path8, NULL));
+  
+  _dbus_assert (find_handler (tree, path1) != tree->root);
+  _dbus_assert (find_handler (tree, path2) != tree->root);
+  _dbus_assert (find_handler (tree, path3) != tree->root);
+  _dbus_assert (find_handler (tree, path4) != tree->root);
+  _dbus_assert (find_handler (tree, path5) != tree->root);
+  _dbus_assert (find_handler (tree, path6) != tree->root);
+  _dbus_assert (find_handler (tree, path7) != tree->root);
+  _dbus_assert (find_handler (tree, path8) != tree->root);
+  
+  /* Check that destroying tree calls unregister funcs */
+  _dbus_object_tree_unref (tree);
+
+  i = 0;
+  while (i < (int) _DBUS_N_ELEMENTS (tree_test_data))
+    {
+      _dbus_assert (tree_test_data[i].handler_unregistered);
+      _dbus_assert (!tree_test_data[i].message_handled);
+      ++i;
+    }
+
+  /* Now start again and try the individual unregister function */
+  tree = _dbus_object_tree_new (NULL);
+  if (tree == NULL)
+    goto out;
+
+  if (!do_register (tree, path1, 0, tree_test_data))
+    goto out;
+  if (!do_register (tree, path2, 1, tree_test_data))
+    goto out;
+  if (!do_register (tree, path3, 2, tree_test_data))
+    goto out;
+  if (!do_register (tree, path4, 3, tree_test_data))
+    goto out;
+  if (!do_register (tree, path5, 4, tree_test_data))
+    goto out;
+  if (!do_register (tree, path6, 5, tree_test_data))
+    goto out;
+  if (!do_register (tree, path7, 6, tree_test_data))
+    goto out;
+  if (!do_register (tree, path8, 7, tree_test_data))
+    goto out;
+  
+  _dbus_object_tree_unregister_and_unlock (tree, path1);
+
+  _dbus_assert (!find_subtree (tree, path1, NULL));
+  _dbus_assert (find_subtree (tree, path2, NULL));
+  _dbus_assert (find_subtree (tree, path3, NULL));
+  _dbus_assert (find_subtree (tree, path4, NULL));
+  _dbus_assert (find_subtree (tree, path5, NULL));
+  _dbus_assert (find_subtree (tree, path6, NULL));
+  _dbus_assert (find_subtree (tree, path7, NULL));
+  _dbus_assert (find_subtree (tree, path8, NULL));
+
+  _dbus_object_tree_unregister_and_unlock (tree, path2);
+
+  _dbus_assert (!find_subtree (tree, path1, NULL));
+  _dbus_assert (!find_subtree (tree, path2, NULL));
+  _dbus_assert (find_subtree (tree, path3, NULL));
+  _dbus_assert (find_subtree (tree, path4, NULL));
+  _dbus_assert (find_subtree (tree, path5, NULL));
+  _dbus_assert (find_subtree (tree, path6, NULL));
+  _dbus_assert (find_subtree (tree, path7, NULL));
+  _dbus_assert (find_subtree (tree, path8, NULL));
+  
+  _dbus_object_tree_unregister_and_unlock (tree, path3);
+
+  _dbus_assert (!find_subtree (tree, path1, NULL));
+  _dbus_assert (!find_subtree (tree, path2, NULL));
+  _dbus_assert (!find_subtree (tree, path3, NULL));
+  _dbus_assert (find_subtree (tree, path4, NULL));
+  _dbus_assert (find_subtree (tree, path5, NULL));
+  _dbus_assert (find_subtree (tree, path6, NULL));
+  _dbus_assert (find_subtree (tree, path7, NULL));
+  _dbus_assert (find_subtree (tree, path8, NULL));
+  
+  _dbus_object_tree_unregister_and_unlock (tree, path4);
+
+  _dbus_assert (!find_subtree (tree, path1, NULL));
+  _dbus_assert (!find_subtree (tree, path2, NULL));
+  _dbus_assert (!find_subtree (tree, path3, NULL));
+  _dbus_assert (!find_subtree (tree, path4, NULL));
+  _dbus_assert (find_subtree (tree, path5, NULL));
+  _dbus_assert (find_subtree (tree, path6, NULL));
+  _dbus_assert (find_subtree (tree, path7, NULL));
+  _dbus_assert (find_subtree (tree, path8, NULL));
+  
+  _dbus_object_tree_unregister_and_unlock (tree, path5);
+
+  _dbus_assert (!find_subtree (tree, path1, NULL));
+  _dbus_assert (!find_subtree (tree, path2, NULL));
+  _dbus_assert (!find_subtree (tree, path3, NULL));
+  _dbus_assert (!find_subtree (tree, path4, NULL));
+  _dbus_assert (!find_subtree (tree, path5, NULL));
+  _dbus_assert (find_subtree (tree, path6, NULL));
+  _dbus_assert (find_subtree (tree, path7, NULL));
+  _dbus_assert (find_subtree (tree, path8, NULL));
+  
+  _dbus_object_tree_unregister_and_unlock (tree, path6);
+
+  _dbus_assert (!find_subtree (tree, path1, NULL));
+  _dbus_assert (!find_subtree (tree, path2, NULL));
+  _dbus_assert (!find_subtree (tree, path3, NULL));
+  _dbus_assert (!find_subtree (tree, path4, NULL));
+  _dbus_assert (!find_subtree (tree, path5, NULL));
+  _dbus_assert (!find_subtree (tree, path6, NULL));
+  _dbus_assert (find_subtree (tree, path7, NULL));
+  _dbus_assert (find_subtree (tree, path8, NULL));
+
+  _dbus_object_tree_unregister_and_unlock (tree, path7);
+
+  _dbus_assert (!find_subtree (tree, path1, NULL));
+  _dbus_assert (!find_subtree (tree, path2, NULL));
+  _dbus_assert (!find_subtree (tree, path3, NULL));
+  _dbus_assert (!find_subtree (tree, path4, NULL));
+  _dbus_assert (!find_subtree (tree, path5, NULL));
+  _dbus_assert (!find_subtree (tree, path6, NULL));
+  _dbus_assert (!find_subtree (tree, path7, NULL));
+  _dbus_assert (find_subtree (tree, path8, NULL));
+
+  _dbus_object_tree_unregister_and_unlock (tree, path8);
+
+  _dbus_assert (!find_subtree (tree, path1, NULL));
+  _dbus_assert (!find_subtree (tree, path2, NULL));
+  _dbus_assert (!find_subtree (tree, path3, NULL));
+  _dbus_assert (!find_subtree (tree, path4, NULL));
+  _dbus_assert (!find_subtree (tree, path5, NULL));
+  _dbus_assert (!find_subtree (tree, path6, NULL));
+  _dbus_assert (!find_subtree (tree, path7, NULL));
+  _dbus_assert (!find_subtree (tree, path8, NULL));
+  
+  i = 0;
+  while (i < (int) _DBUS_N_ELEMENTS (tree_test_data))
+    {
+      _dbus_assert (tree_test_data[i].handler_unregistered);
+      _dbus_assert (!tree_test_data[i].message_handled);
+      ++i;
+    }
+
+  /* Register it all again, and test dispatch */
+
+  if (!do_register (tree, path1, 0, tree_test_data))
+    goto out;
+  if (!do_register (tree, path2, 1, tree_test_data))
+    goto out;
+  if (!do_register (tree, path3, 2, tree_test_data))
+    goto out;
+  if (!do_register (tree, path4, 3, tree_test_data))
+    goto out;
+  if (!do_register (tree, path5, 4, tree_test_data))
+    goto out;
+  if (!do_register (tree, path6, 5, tree_test_data))
+    goto out;
+  if (!do_register (tree, path7, 6, tree_test_data))
+    goto out;
+  if (!do_register (tree, path8, 7, tree_test_data))
+    goto out;
+
+#if 0
+  spew_tree (tree);
+#endif
+  
+  if (!do_test_dispatch (tree, path1, 0, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
+    goto out;
+  if (!do_test_dispatch (tree, path2, 1, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
+    goto out;
+  if (!do_test_dispatch (tree, path3, 2, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
+    goto out;
+  if (!do_test_dispatch (tree, path4, 3, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
+    goto out;
+  if (!do_test_dispatch (tree, path5, 4, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
+    goto out;
+  if (!do_test_dispatch (tree, path6, 5, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
+    goto out;
+  if (!do_test_dispatch (tree, path7, 6, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
+    goto out;
+  if (!do_test_dispatch (tree, path8, 7, tree_test_data, _DBUS_N_ELEMENTS (tree_test_data)))
+    goto out;
+  
+ out:
+  if (tree)
+    {
+      /* test ref */
+      _dbus_object_tree_ref (tree);
+      _dbus_object_tree_unref (tree);
+      _dbus_object_tree_unref (tree);
+    }
+
+  return TRUE;
+}
+
+/**
+ * @ingroup DBusObjectTree
+ * Unit test for DBusObjectTree
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_object_tree_test (void)
+{
+  _dbus_test_oom_handling ("object tree",
+                           object_tree_test_iteration,
+                           NULL);
+
+  return TRUE;
+}
+
+#endif /* DBUS_BUILD_TESTS */