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, 1249 insertions, 0 deletions

diff --git a/glib/dbus-gproxy.c b/glib/dbus-gproxy.c
new file mode 100644
index 00000000..99900e4c
--- /dev/null
+++ b/glib/dbus-gproxy.c
@@ -0,0 +1,1249 @@
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-gcall.c convenience routines for calling methods, etc.
+ *
+ * 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-glib.h"
+#include <string.h>
+
+/**
+ * @addtogroup DBusGLibInternals
+ *
+ * @{
+ */
+
+typedef struct DBusGProxyManager DBusGProxyManager;
+
+/**
+ * Internals of DBusGProxy
+ */
+struct DBusGProxy
+{
+  GObject parent;             /**< Parent instance */
+  
+  DBusGProxyManager *manager; /**< Proxy manager */
+  char *service;              /**< Service messages go to or NULL */
+  char *path;                 /**< Path messages go to or NULL */
+  char *interface;            /**< Interface messages go to or NULL */
+};
+
+/**
+ * Class struct for DBusGProxy
+ */
+struct DBusGProxyClass
+{
+  GObjectClass parent_class;  
+};
+
+static void dbus_gproxy_init          (DBusGProxy      *proxy);
+static void dbus_gproxy_class_init    (DBusGProxyClass *klass);
+static void dbus_gproxy_finalize      (GObject         *object);
+static void dbus_gproxy_dispose       (GObject         *object);
+static void dbus_gproxy_destroy       (DBusGProxy      *proxy);
+static void dbus_gproxy_emit_received (DBusGProxy      *proxy,
+                                       DBusMessage     *message);
+
+
+/**
+ * A list of proxies with a given service+path+interface, used to route incoming
+ * signals.
+ */
+typedef struct
+{
+  GSList *proxies;
+
+  char name[4]; /**< service (empty string for none), nul byte,
+                 *   path, nul byte,
+                 *   interface, nul byte
+                 */
+  
+} DBusGProxyList;
+
+/**
+ * DBusGProxyManager's primary task is to route signals to the proxies
+ * those signals are emitted on. In order to do this it also has to
+ * track the owners of the services proxies are bound to.
+ */
+struct DBusGProxyManager
+{
+  GStaticMutex lock; /**< Thread lock */
+  int refcount;      /**< Reference count */
+  DBusConnection *connection; /**< Connection we're associated with. */
+
+  GHashTable *proxy_lists; /**< Hash used to route incoming signals
+                            *   and iterate over proxies
+                            */
+
+};
+
+static void              dbus_gproxy_manager_ref    (DBusGProxyManager *manager);
+static DBusHandlerResult dbus_gproxy_manager_filter (DBusConnection    *connection,
+                                                     DBusMessage       *message,
+                                                     void              *user_data);
+
+/** Lock the DBusGProxyManager */
+#define LOCK_MANAGER(mgr)   (g_static_mutex_lock (&(mgr)->lock))
+/** Unlock the DBusGProxyManager */
+#define UNLOCK_MANAGER(mgr) (g_static_mutex_unlock (&(mgr)->lock))
+
+static int gproxy_manager_slot = -1;
+
+/* Lock controlling get/set manager as data on each connection */
+static GStaticMutex connection_gproxy_lock = G_STATIC_MUTEX_INIT;
+
+static DBusGProxyManager*
+dbus_gproxy_manager_get (DBusConnection *connection)
+{
+  DBusGProxyManager *manager;
+
+  dbus_connection_allocate_data_slot (&gproxy_manager_slot);
+  if (gproxy_manager_slot < 0)
+    g_error ("out of memory");
+  
+  g_static_mutex_lock (&connection_gproxy_lock);
+  
+  manager = dbus_connection_get_data (connection, gproxy_manager_slot);
+  if (manager != NULL)
+    {
+      dbus_connection_free_data_slot (&gproxy_manager_slot);
+      dbus_gproxy_manager_ref (manager);
+      g_static_mutex_unlock (&connection_gproxy_lock);
+      return manager;
+    }
+  
+  manager = g_new0 (DBusGProxyManager, 1);
+
+  manager->refcount = 1;
+  manager->connection = connection;
+  
+  g_static_mutex_init (&manager->lock);
+
+  /* Proxy managers keep the connection alive, which means that
+   * DBusGProxy indirectly does. To free a connection you have to free
+   * all the proxies referring to it.
+   */
+  dbus_connection_ref (manager->connection);
+
+  dbus_connection_set_data (connection, gproxy_manager_slot,
+                            manager, NULL);
+
+  dbus_connection_add_filter (connection, dbus_gproxy_manager_filter,
+                              manager, NULL);
+  
+  g_static_mutex_unlock (&connection_gproxy_lock);
+  
+  return manager;
+}
+
+static void
+dbus_gproxy_manager_ref (DBusGProxyManager *manager)
+{
+  g_assert (manager != NULL);
+  g_assert (manager->refcount > 0);
+
+  LOCK_MANAGER (manager);
+  
+  manager->refcount += 1;
+
+  UNLOCK_MANAGER (manager);
+}
+
+static void
+dbus_gproxy_manager_unref (DBusGProxyManager *manager)
+{
+  g_assert (manager != NULL);
+  g_assert (manager->refcount > 0);
+
+  LOCK_MANAGER (manager);
+  manager->refcount -= 1;
+  if (manager->refcount == 0)
+    {
+      UNLOCK_MANAGER (manager);
+
+      if (manager->proxy_lists)
+        {
+          /* can't have any proxies left since they hold
+           * a reference to the proxy manager.
+           */
+          g_assert (g_hash_table_size (manager->proxy_lists) == 0);
+          
+          g_hash_table_destroy (manager->proxy_lists);
+          manager->proxy_lists = NULL;
+        }
+      
+      g_static_mutex_free (&manager->lock);
+
+      g_static_mutex_lock (&connection_gproxy_lock);
+
+      dbus_connection_remove_filter (manager->connection, dbus_gproxy_manager_filter,
+                                     manager);
+      
+      dbus_connection_set_data (manager->connection,
+                                gproxy_manager_slot,
+                                NULL, NULL);
+
+      g_static_mutex_unlock (&connection_gproxy_lock);
+      
+      dbus_connection_unref (manager->connection);
+      g_free (manager);
+
+      dbus_connection_free_data_slot (&gproxy_manager_slot);
+    }
+  else
+    {
+      UNLOCK_MANAGER (manager);
+    }
+}
+
+static guint
+tristring_hash (gconstpointer key)
+{
+  const char *p = key;
+  guint h = *p;
+
+  if (h)
+    {
+      for (p += 1; *p != '\0'; p++)
+        h = (h << 5) - h + *p;
+    }
+
+  /* skip nul and do the next substring */
+  for (p += 1; *p != '\0'; p++)
+    h = (h << 5) - h + *p;
+
+  /* skip nul again and another substring */
+  for (p += 1; *p != '\0'; p++)
+    h = (h << 5) - h + *p;
+  
+  return h;
+}
+
+static gboolean
+strequal_len (const char *a,
+              const char *b,
+              size_t     *lenp)
+{
+  size_t a_len;
+  size_t b_len;
+
+  a_len = strlen (a);
+  b_len = strlen (b);
+
+  if (a_len != b_len)
+    return FALSE;
+
+  if (memcmp (a, b, a_len) != 0)
+    return FALSE;
+  
+  *lenp = a_len;
+
+  return TRUE;
+}
+
+static gboolean
+tristring_equal (gconstpointer  a,
+                 gconstpointer  b)
+{
+  const char *ap = a;
+  const char *bp = b;
+  size_t len;
+
+  if (!strequal_len (ap, bp, &len))
+    return FALSE;
+
+  ap += len + 1;
+  bp += len + 1;
+
+  if (!strequal_len (ap, bp, &len))
+    return FALSE;
+
+  ap += len + 1;
+  bp += len + 1;
+
+  if (strcmp (ap, bp) != 0)
+    return FALSE;
+  
+  return TRUE;
+}
+
+static char*
+tristring_alloc_from_strings (size_t      padding_before,
+                              const char *service,
+                              const char *path,
+                              const char *interface)
+{
+  size_t service_len, iface_len, path_len, len;
+  char *tri;
+  
+  if (service)
+    service_len = strlen (service);
+  else
+    service_len = 0;
+
+  path_len = strlen (path);
+  
+  iface_len = strlen (interface);
+
+  tri = g_malloc (padding_before + service_len + path_len + iface_len + 3);
+
+  len = padding_before;
+  
+  if (service)
+    memcpy (&tri[len], service, service_len);
+
+  len += service_len;
+  tri[len] = '\0';
+  len += 1;
+
+  g_assert (len == (padding_before + service_len + 1));
+  
+  memcpy (&tri[len], path, path_len);
+  len += path_len;
+  tri[len] = '\0';
+  len += 1;
+
+  g_assert (len == (padding_before + service_len + path_len + 2));
+  
+  memcpy (&tri[len], interface, iface_len);
+  len += iface_len;
+  tri[len] = '\0';
+  len += 1;
+
+  g_assert (len == (padding_before + service_len + path_len + iface_len + 3));
+
+  return tri;
+}
+
+static char*
+tristring_from_proxy (DBusGProxy *proxy)
+{
+  return tristring_alloc_from_strings (0,
+                                       proxy->service,
+                                       proxy->path,
+                                       proxy->interface);
+}
+
+static char*
+tristring_from_message (DBusMessage *message)
+{
+  return tristring_alloc_from_strings (0,
+                                       dbus_message_get_sender (message),
+                                       dbus_message_get_path (message),
+                                       dbus_message_get_interface (message));
+}
+
+static DBusGProxyList*
+gproxy_list_new (DBusGProxy *first_proxy)
+{
+  DBusGProxyList *list;
+  
+  list = (void*) tristring_alloc_from_strings (G_STRUCT_OFFSET (DBusGProxyList, name),
+                                               first_proxy->service,
+                                               first_proxy->path,
+                                               first_proxy->interface);
+  list->proxies = NULL;
+
+  return list;
+}
+
+static void
+gproxy_list_free (DBusGProxyList *list)
+{
+  /* we don't hold a reference to the proxies in the list,
+   * as they ref the GProxyManager
+   */
+  g_slist_free (list->proxies);  
+
+  g_free (list);
+}
+
+static char*
+gproxy_get_match_rule (DBusGProxy *proxy)
+{
+  /* FIXME Some sort of escaping is required here I think */
+  
+  if (proxy->service)
+    return g_strdup_printf ("type='signal',service='%s',path='%s',interface='%s'",
+                            proxy->service, proxy->path, proxy->interface);
+  else
+    return g_strdup_printf ("type='signal',path='%s',interface='%s'",
+                            proxy->path, proxy->interface);
+}
+
+static void
+dbus_gproxy_manager_register (DBusGProxyManager *manager,
+                              DBusGProxy        *proxy)
+{
+  DBusGProxyList *list;
+
+  LOCK_MANAGER (manager);
+
+  if (manager->proxy_lists == NULL)
+    {
+      list = NULL;
+      manager->proxy_lists = g_hash_table_new_full (tristring_hash,
+                                                    tristring_equal,
+                                                    NULL,
+                                                    (GFreeFunc) gproxy_list_free);
+    }
+  else
+    {
+      char *tri;
+
+      tri = tristring_from_proxy (proxy);
+      
+      list = g_hash_table_lookup (manager->proxy_lists, tri);
+
+      g_free (tri);
+    }
+      
+  if (list == NULL)
+    {
+      list = gproxy_list_new (proxy);
+      
+      g_hash_table_replace (manager->proxy_lists,
+                            list->name, list);
+    }
+
+  if (list->proxies == NULL)
+    {
+      /* We have to add the match rule to the server,
+       * but FIXME only if the server is a message bus,
+       * not if it's a peer.
+       */
+      char *rule;
+
+      rule = gproxy_get_match_rule (proxy);
+      
+      /* We don't check for errors; it's not like anyone would handle them,
+       * and we don't want a round trip here.
+       */
+      dbus_bus_add_match (manager->connection,
+                          rule, NULL);
+
+      g_free (rule);
+    }
+
+  g_assert (g_slist_find (list->proxies, proxy) == NULL);
+  
+  list->proxies = g_slist_prepend (list->proxies, proxy);
+  
+  UNLOCK_MANAGER (manager);
+}
+
+static void
+dbus_gproxy_manager_unregister (DBusGProxyManager *manager,
+                                DBusGProxy        *proxy)
+{
+  DBusGProxyList *list;
+  char *tri;
+  
+  LOCK_MANAGER (manager);
+
+#ifndef G_DISABLE_CHECKS
+  if (manager->proxy_lists == NULL)
+    {
+      g_warning ("Trying to disconnect a signal on a proxy but none are connected\n");
+      return;
+    }
+#endif
+
+  tri = tristring_from_proxy (proxy);
+  
+  list = g_hash_table_lookup (manager->proxy_lists, tri);
+  
+  g_free (tri);
+
+#ifndef G_DISABLE_CHECKS
+  if (list == NULL)
+    {
+      g_warning ("Trying to disconnect a signal on a proxy but none are connected\n");
+      return;
+    }
+#endif
+
+  g_assert (g_slist_find (list->proxies, proxy) != NULL);
+  
+  list->proxies = g_slist_remove (list->proxies, proxy);
+
+  g_assert (g_slist_find (list->proxies, proxy) == NULL);
+
+  if (g_hash_table_size (manager->proxy_lists) == 0)
+    {
+      g_hash_table_destroy (manager->proxy_lists);
+      manager->proxy_lists = NULL;
+    }
+  
+  UNLOCK_MANAGER (manager);
+}
+
+static void
+list_proxies_foreach (gpointer key,
+                      gpointer value,
+                      gpointer user_data)
+{
+  DBusGProxyList *list;
+  GSList **ret;
+  GSList *tmp;
+  
+  list = value;
+  ret = user_data;
+
+  tmp = list->proxies;
+  while (tmp != NULL)
+    {
+      DBusGProxy *proxy = DBUS_GPROXY (tmp->data);
+
+      g_object_ref (proxy);
+      *ret = g_slist_prepend (*ret, proxy);
+      
+      tmp = tmp->next;
+    }
+}
+
+static GSList*
+dbus_gproxy_manager_list_all (DBusGProxyManager *manager)
+{
+  GSList *ret;
+
+  ret = NULL;
+
+  if (manager->proxy_lists)
+    {
+      g_hash_table_foreach (manager->proxy_lists,
+                            list_proxies_foreach,
+                            &ret);
+    }
+
+  return ret;
+}
+
+static DBusHandlerResult
+dbus_gproxy_manager_filter (DBusConnection    *connection,
+                            DBusMessage       *message,
+                            void              *user_data)
+{
+  DBusGProxyManager *manager;
+  
+  if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_SIGNAL)
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+  manager = user_data;
+
+  dbus_gproxy_manager_ref (manager);
+  
+  LOCK_MANAGER (manager);
+  
+  if (dbus_message_is_signal (message,
+                              DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL,
+                              "Disconnected"))
+    {
+      /* Destroy all the proxies, quite possibly resulting in unreferencing
+       * the proxy manager and the connection as well.
+       */
+      GSList *all;
+      GSList *tmp;
+
+      all = dbus_gproxy_manager_list_all (manager);
+
+      tmp = all;
+      while (tmp != NULL)
+        {
+          DBusGProxy *proxy;
+
+          proxy = DBUS_GPROXY (tmp->data);
+
+          UNLOCK_MANAGER (manager);
+          dbus_gproxy_destroy (proxy);
+          g_object_unref (G_OBJECT (proxy));
+          LOCK_MANAGER (manager);
+          
+          tmp = tmp->next;
+        }
+
+      g_slist_free (all);
+
+#ifndef G_DISABLE_CHECKS
+      if (manager->proxy_lists != NULL)
+        g_warning ("Disconnection emitted \"destroy\" on all DBusGProxy, but somehow new proxies were created in response to one of those destroy signals. This will cause a memory leak.");
+#endif
+    }
+  else
+    {
+      char *tri;
+      DBusGProxyList *list;
+      
+      tri = tristring_from_message (message);
+
+      if (manager->proxy_lists)
+        list = g_hash_table_lookup (manager->proxy_lists, tri);
+      else
+        list = NULL;
+
+      g_free (tri);
+
+      /* Emit the signal */
+      
+      if (list != NULL)
+        {
+          GSList *tmp;
+          GSList *copy;
+
+          copy = g_slist_copy (list->proxies);
+          g_slist_foreach (copy, (GFunc) g_object_ref, NULL);
+          
+          tmp = copy;
+          while (tmp != NULL)
+            {
+              DBusGProxy *proxy;
+
+              proxy = DBUS_GPROXY (tmp->data);
+
+              UNLOCK_MANAGER (manager);
+              dbus_gproxy_emit_received (proxy, message);
+              g_object_unref (G_OBJECT (proxy));
+              LOCK_MANAGER (manager);
+              
+              tmp = tmp->next;
+            }
+
+          g_slist_free (copy);
+        }
+    }
+
+  UNLOCK_MANAGER (manager);
+  dbus_gproxy_manager_unref (manager);
+  
+  /* "Handling" signals doesn't make sense, they are for everyone
+   * who cares
+   */
+  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+
+
+/*      ---------- DBusGProxy --------------   */
+
+
+
+enum
+{
+  DESTROY,
+  RECEIVED,
+  LAST_SIGNAL
+};
+
+static void *parent_class;
+static guint signals[LAST_SIGNAL] = { 0 };
+
+static void
+dbus_gproxy_init (DBusGProxy *proxy)
+{
+  /* Nothing */
+}
+
+static void
+dbus_gproxy_class_init (DBusGProxyClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  
+  parent_class = g_type_class_peek_parent (klass);
+  
+  object_class->finalize = dbus_gproxy_finalize;
+  object_class->dispose = dbus_gproxy_dispose;
+  
+  signals[DESTROY] =
+    g_signal_new ("destroy",
+		  G_OBJECT_CLASS_TYPE (object_class),
+                  G_SIGNAL_RUN_CLEANUP | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
+                  0,
+		  NULL, NULL,
+                  g_cclosure_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
+  
+  signals[RECEIVED] =
+    g_signal_new ("received",
+		  G_OBJECT_CLASS_TYPE (object_class),
+		  G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
+                  0,
+		  NULL, NULL,
+                  g_cclosure_marshal_VOID__BOXED,
+		  G_TYPE_NONE, 1,
+                  DBUS_TYPE_MESSAGE);
+}
+
+
+static void
+dbus_gproxy_dispose (GObject *object)
+{
+  DBusGProxy *proxy;
+
+  proxy = DBUS_GPROXY (object);
+
+  g_signal_emit (object, signals[DESTROY], 0);
+  
+  G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+dbus_gproxy_finalize (GObject *object)
+{
+  DBusGProxy *proxy;
+
+  proxy = DBUS_GPROXY (object);
+
+  if (proxy->manager)
+    {
+      dbus_gproxy_manager_unregister (proxy->manager, proxy);
+      dbus_gproxy_manager_unref (proxy->manager);
+    }
+  
+  g_free (proxy->service);
+  g_free (proxy->path);
+  g_free (proxy->interface);
+  
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+dbus_gproxy_destroy (DBusGProxy *proxy)
+{
+  /* FIXME do we need the GTK_IN_DESTRUCTION style flag
+   * from GtkObject?
+   */
+  g_object_run_dispose (G_OBJECT (proxy));
+}
+
+static char*
+create_signal_detail (const char *interface,
+                      const char *signal)
+{
+  GString *str;
+
+  str = g_string_new (interface);
+
+  g_string_append (str, ".");
+
+  g_string_append (str, signal);
+
+  return g_string_free (str, FALSE);
+}
+
+static void
+dbus_gproxy_emit_received (DBusGProxy  *proxy,
+                           DBusMessage *message)
+{
+  const char *interface;
+  const char *signal;
+  char *detail;
+  GQuark q;
+  
+  interface = dbus_message_get_interface (message);
+  signal = dbus_message_get_member (message);
+
+  g_assert (interface != NULL);
+  g_assert (signal != NULL);
+
+  detail = create_signal_detail (interface, signal);
+
+  /* If the quark isn't preexisting, there's no way there
+   * are any handlers connected. We don't want to create
+   * extra quarks for every possible signal.
+   */
+  q = g_quark_try_string (detail);
+
+  if (q != 0)
+    g_signal_emit (G_OBJECT (proxy),
+                   signals[RECEIVED],
+                   q,
+                   message);
+
+  g_free (detail);
+}
+
+/** @} End of DBusGLibInternals */
+
+/** @addtogroup DBusGLib
+ * @{
+ */
+
+/**
+ * Standard GObject get_type() function for DBusGProxy.
+ *
+ * @returns type ID for DBusGProxy class
+ */
+GType
+dbus_gproxy_get_type (void)
+{
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+        {
+          sizeof (DBusGProxyClass),
+          (GBaseInitFunc) NULL,
+          (GBaseFinalizeFunc) NULL,
+          (GClassInitFunc) dbus_gproxy_class_init,
+          NULL,           /* class_finalize */
+          NULL,           /* class_data */
+          sizeof (DBusGProxy),
+          0,              /* n_preallocs */
+          (GInstanceInitFunc) dbus_gproxy_init,
+        };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "DBusGProxy",
+                                            &object_info, 0);
+    }
+  
+  return object_type;
+}
+
+static DBusGProxy*
+dbus_gproxy_new (DBusConnection *connection,
+                 const char     *service_name,
+                 const char     *path_name,
+                 const char     *interface_name)
+{
+  DBusGProxy *proxy;
+
+  g_assert (connection != NULL);
+  
+  proxy = g_object_new (DBUS_TYPE_GPROXY, NULL);
+
+  /* These should all be construct-only mandatory properties,
+   * for now we just don't let people use g_object_new().
+   */
+  
+  proxy->manager = dbus_gproxy_manager_get (connection);
+  
+  proxy->service = g_strdup (service_name);
+  proxy->path = g_strdup (path_name);
+  proxy->interface = g_strdup (interface_name);
+
+  dbus_gproxy_manager_register (proxy->manager, proxy);
+  
+  return proxy;
+}
+
+/**
+ * Creates a new proxy for a remote interface exported by a service on
+ * a message bus. Method calls and signal connections over this proxy
+ * will go to the service owner; the service owner is expected to
+ * support the given interface name. THE SERVICE OWNER MAY CHANGE OVER
+ * TIME, for example between two different method calls. If you need a
+ * fixed owner, you need to request the current owner and bind a proxy
+ * to that rather than to the generic service name; see
+ * dbus_gproxy_new_for_service_owner().
+ *
+ * A service-associated proxy only makes sense with a message bus,
+ * not for app-to-app direct dbus connections.
+ *
+ * This proxy will only emit the "destroy" signal if the #DBusConnection
+ * is disconnected or the proxy is has no remaining references.
+ *
+ * @param connection the connection to the remote bus
+ * @param service_name name of the service on the message bus
+ * @param path_name name of the object inside the service to call methods on
+ * @param interface_name name of the interface to call methods on
+ * @returns new proxy object
+ */
+DBusGProxy*
+dbus_gproxy_new_for_service (DBusConnection *connection,
+                             const char     *service_name,
+                             const char     *path_name,
+                             const char     *interface_name)
+{
+  DBusGProxy *proxy;
+
+  g_return_val_if_fail (connection != NULL, NULL);
+  g_return_val_if_fail (service_name != NULL, NULL);
+  g_return_val_if_fail (path_name != NULL, NULL);
+  g_return_val_if_fail (interface_name != NULL, NULL);
+  
+  proxy = dbus_gproxy_new (connection, service_name,
+                           path_name, interface_name);
+
+  return proxy;
+}
+
+/**
+ * Similar to dbus_gproxy_new_for_service(), but makes a round-trip
+ * request to the message bus to get the current service owner, then
+ * binds the proxy specifically to the current owner. As a result, the
+ * service owner will not change over time, and the proxy will emit
+ * the "destroy" signal when the owner disappears from the message
+ * bus.
+ *
+ * An example of the difference between dbus_gproxy_new_for_service()
+ * and dbus_gproxy_new_for_service_owner(): if you pass the service name
+ * "org.freedesktop.Database" dbus_gproxy_new_for_service() remains bound
+ * to that name as it changes owner. dbus_gproxy_new_for_service_owner()
+ * will fail if the service has no owner. If the service has an owner,
+ * dbus_gproxy_new_for_service_owner() will bind to the unique name
+ * of that owner rather than the generic service name.
+ * 
+ * @param connection the connection to the remote bus
+ * @param service_name name of the service on the message bus
+ * @param path_name name of the object inside the service to call methods on
+ * @param interface_name name of the interface to call methods on
+ * @param error return location for an error
+ * @returns new proxy object, or #NULL on error
+ */
+DBusGProxy*
+dbus_gproxy_new_for_service_owner (DBusConnection           *connection,
+                                   const char               *service_name,
+                                   const char               *path_name,
+                                   const char               *interface_name,
+                                   GError                  **error)
+{
+  g_return_val_if_fail (connection != NULL, NULL);
+  g_return_val_if_fail (service_name != NULL, NULL);
+  g_return_val_if_fail (path_name != NULL, NULL);
+  g_return_val_if_fail (interface_name != NULL, NULL);
+
+
+}
+
+/**
+ * Creates a proxy for an object in peer application (one
+ * we're directly connected to). That is, this function is
+ * intended for use when there's no message bus involved,
+ * we're doing a simple 1-to-1 communication between two
+ * applications.
+ *
+ *
+ * @param connection the connection to the peer
+ * @param path_name name of the object inside the peer to call methods on
+ * @param interface_name name of the interface to call methods on
+ * @returns new proxy object
+ * 
+ */
+DBusGProxy*
+dbus_gproxy_new_for_peer (DBusConnection           *connection,
+                          const char               *path_name,
+                          const char               *interface_name)
+{
+  DBusGProxy *proxy;
+  
+  g_return_val_if_fail (connection != NULL, NULL);
+  g_return_val_if_fail (path_name != NULL, NULL);
+  g_return_val_if_fail (interface_name != NULL, NULL);
+
+  proxy = dbus_gproxy_new (connection, NULL,
+                           path_name, interface_name);
+
+  return proxy;
+}
+
+/**
+ * Invokes a method on a remote interface. This function does not
+ * block; instead it returns an opaque #DBusPendingCall object that
+ * tracks the pending call.  The method call will not be sent over the
+ * wire until the application returns to the main loop, or blocks in
+ * dbus_connection_flush() to write out pending data.  The call will
+ * be completed after a timeout, or when a reply is received.
+ * To collect the results of the call (which may be an error,
+ * or a reply), use dbus_gproxy_end_call().
+ *
+ * @todo this particular function shouldn't die on out of memory,
+ * since you should be able to do a call with large arguments.
+ * 
+ * @param proxy a proxy for a remote interface
+ * @param method the name of the method to invoke
+ * @param first_arg_type type of the first argument
+ *
+ * @returns opaque pending call object
+ *  */
+DBusPendingCall*
+dbus_gproxy_begin_call (DBusGProxy *proxy,
+                        const char *method,
+                        int         first_arg_type,
+                        ...)
+{
+  DBusPendingCall *pending;
+  DBusMessage *message;
+  va_list args;
+  
+  g_return_val_if_fail (DBUS_IS_GPROXY (proxy), NULL);
+
+  message = dbus_message_new_method_call (proxy->service,
+                                          proxy->path,
+                                          proxy->interface,
+                                          method);
+  if (message == NULL)
+    goto oom;
+
+  va_start (args, first_arg_type);
+  if (!dbus_message_append_args_valist (message, first_arg_type,
+                                        args))
+    goto oom;
+  va_end (args);
+
+  if (!dbus_connection_send_with_reply (proxy->manager->connection,
+                                        message,
+                                        &pending,
+                                        -1))
+    goto oom;
+
+  return pending;
+
+ oom:
+  /* FIXME we should create a pending call that's
+   * immediately completed with an error status without
+   * ever going on the wire.
+   */
+  
+  g_error ("Out of memory");
+  return NULL;
+}
+
+/**
+ * Collects the results of a method call. The method call was normally
+ * initiated with dbus_gproxy_end_call(). This function will block if
+ * the results haven't yet been received; use
+ * dbus_pending_call_set_notify() to be notified asynchronously that a
+ * pending call has been completed. Use
+ * dbus_pending_call_get_completed() to check whether a call has been
+ * completed. If it's completed, it will not block.
+ *
+ * If the call results in an error, the error is set as normal for
+ * GError and the function returns #FALSE.
+ *
+ * Otherwise, the "out" parameters and return value of the
+ * method are stored in the provided varargs list.
+ * The list should be terminated with DBUS_TYPE_INVALID.
+ *
+ * This function doesn't affect the reference count of the
+ * #DBusPendingCall, the caller of dbus_gproxy_begin_call() still owns
+ * a reference.
+ *
+ * @param proxy a proxy for a remote interface
+ * @param pending the pending call from dbus_gproxy_begin_call()
+ * @param error return location for an error
+ * @param first_arg_type type of first "out" argument
+ * @returns #FALSE if an error is set */
+gboolean
+dbus_gproxy_end_call (DBusGProxy          *proxy,
+                      DBusPendingCall     *pending,
+                      GError             **error,
+                      int                  first_arg_type,
+                      ...)
+{
+  DBusMessage *message;
+  va_list args;
+  DBusError derror;
+  
+  g_return_val_if_fail (DBUS_IS_GPROXY (proxy), FALSE);
+  g_return_val_if_fail (pending != NULL, FALSE);
+
+  dbus_pending_call_block (pending);
+  message = dbus_pending_call_get_reply (pending);
+
+  g_assert (message != NULL);
+
+  dbus_error_init (&derror);
+  va_start (args, first_arg_type);
+  if (!dbus_message_get_args_valist (message, &derror, first_arg_type, args))
+    {
+      va_end (args);
+      goto error;
+    }
+  va_end (args);
+
+  return TRUE;
+
+ error:
+  dbus_set_g_error (error, &derror);
+  dbus_error_free (&derror);
+  return FALSE;
+}
+
+/**
+ * Sends a method call message as with dbus_gproxy_begin_call(), but
+ * does not ask for a reply or allow you to receive one.
+ *
+ * @todo this particular function shouldn't die on out of memory,
+ * since you should be able to do a call with large arguments.
+ * 
+ * @param proxy a proxy for a remote interface
+ * @param method the name of the method to invoke
+ * @param first_arg_type type of the first argument
+ */
+void
+dbus_gproxy_oneway_call (DBusGProxy               *proxy,
+                         const char               *method,
+                         int                       first_arg_type,
+                         ...)
+{
+  DBusMessage *message;
+  va_list args;
+  
+  g_return_if_fail (DBUS_IS_GPROXY (proxy));
+
+  message = dbus_message_new_method_call (proxy->service,
+                                          proxy->path,
+                                          proxy->interface,
+                                          method);
+  if (message == NULL)
+    goto oom;
+
+  dbus_message_set_no_reply (message, TRUE);
+  
+  va_start (args, first_arg_type);
+  if (!dbus_message_append_args_valist (message, first_arg_type,
+                                        args))
+    goto oom;
+  va_end (args);
+
+  if (!dbus_connection_send (proxy->manager->connection,
+                             message,
+                             NULL))
+    goto oom;
+
+ oom:
+  g_error ("Out of memory");
+}
+
+/**
+ * Sends a message to the interface we're proxying for.  Does not
+ * block or wait for a reply. The message is only actually written out
+ * when you return to the main loop or block in
+ * dbus_connection_flush().
+ *
+ * The message is modified to be addressed to the target interface.
+ * That is, a destination service field or whatever is needed will be
+ * added to the message. The basic point of this function is to add
+ * the necessary header fields, otherwise it's equivalent to
+ * dbus_connection_send().
+ *
+ * This function adds a reference to the message, so the caller
+ * still owns its original reference.
+ * 
+ * @param proxy a proxy for a remote interface
+ * @param message the message to address and send
+ * @param client_serial return location for message's serial, or #NULL */
+void
+dbus_gproxy_send (DBusGProxy          *proxy,
+                  DBusMessage         *message,
+                  dbus_uint32_t       *client_serial)
+{
+  g_return_if_fail (DBUS_IS_GPROXY (proxy));
+  
+  if (proxy->service)
+    {
+      if (!dbus_message_set_destination (message, proxy->service))
+        g_error ("Out of memory");
+    }
+  if (proxy->path)
+    {
+      if (!dbus_message_set_path (message, proxy->path))
+        g_error ("Out of memory");
+    }
+  if (proxy->interface)
+    {
+      if (!dbus_message_set_interface (message, proxy->interface))
+        g_error ("Out of memory");
+    }
+  
+  if (!dbus_connection_send (proxy->manager->connection, message, client_serial))
+    g_error ("Out of memory\n");
+}
+
+void
+dbus_gproxy_connect_signal (DBusGProxy             *proxy,
+                            const char             *signal_name,
+                            DBusGProxySignalHandler handler,
+                            void                   *data,
+                            GClosureNotify          free_data_func)
+{
+  GClosure *closure;
+  char *detail;
+
+  g_return_if_fail (DBUS_IS_GPROXY (proxy));
+  g_return_if_fail (signal_name != NULL);
+  g_return_if_fail (handler != NULL);
+  
+  detail = create_signal_detail (proxy->interface, signal_name);
+  
+  closure = g_cclosure_new (G_CALLBACK (handler), data, free_data_func);
+  g_signal_connect_closure_by_id (G_OBJECT (proxy),
+                                  signals[RECEIVED],
+                                  g_quark_from_string (detail),
+                                  closure, FALSE);
+
+  g_free (detail);
+}
+
+void
+dbus_gproxy_disconnect_signal (DBusGProxy             *proxy,
+                               const char             *signal_name,
+                               DBusGProxySignalHandler handler,
+                               void                   *data)
+{
+  char *detail;
+  GQuark q;
+  
+  g_return_if_fail (DBUS_IS_GPROXY (proxy));
+  g_return_if_fail (signal_name != NULL);
+  g_return_if_fail (handler != NULL);
+
+  detail = create_signal_detail (proxy->interface, signal_name);
+  q = g_quark_try_string (detail);
+  g_free (detail);
+
+#ifndef G_DISABLE_CHECKS
+  if (q == 0)
+    {
+      g_warning ("%s: No signal handlers for %s found on this DBusGProxy",
+                 G_GNUC_FUNCTION, signal_name);
+      return;
+    }
+#endif
+
+  g_signal_handlers_disconnect_matched (G_OBJECT (proxy),
+                                        G_SIGNAL_MATCH_DETAIL |
+                                        G_SIGNAL_MATCH_FUNC   |
+                                        G_SIGNAL_MATCH_DATA,
+                                        signals[RECEIVED],
+                                        q,
+                                        NULL,
+                                        G_CALLBACK (handler), data);
+}
+
+/** @} End of DBusGLib public */
+
+#ifdef DBUS_BUILD_TESTS
+
+/**
+ * @ingroup DBusGLibInternals
+ * Unit test for GLib proxy functions
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_gproxy_test (void)
+{
+  
+  
+  return TRUE;
+}
+
+#endif /* DBUS_BUILD_TESTS */