X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dbus%2Fdbus-server.c;h=19d8590c962dc25b910896ff8b9643cc92db8e76;hb=ca26f36b25beaf3d436043d551489e1ef5e2b661;hp=9fc5cacea3945e830c0d560af13c717dd641058a;hpb=783e066ce311bc293272099934ce957a7b735566;p=platform%2Fupstream%2Fdbus.git diff --git a/dbus/dbus-server.c b/dbus/dbus-server.c index 9fc5cac..19d8590 100644 --- a/dbus/dbus-server.c +++ b/dbus/dbus-server.c @@ -1,4 +1,4 @@ -/* -*- mode: C; c-file-style: "gnu" -*- */ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ /* dbus-server.c DBusServer object * * Copyright (C) 2002, 2003, 2004, 2005 Red Hat Inc. @@ -17,15 +17,16 @@ * * 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 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ +#include #include "dbus-server.h" #include "dbus-server-unix.h" #include "dbus-server-socket.h" #include "dbus-string.h" -#ifdef DBUS_BUILD_TESTS +#ifdef DBUS_ENABLE_EMBEDDED_TESTS #include "dbus-server-debug-pipe.h" #endif #include "dbus-address.h" @@ -52,6 +53,20 @@ * @{ */ +#ifndef _dbus_server_trace_ref +void +_dbus_server_trace_ref (DBusServer *server, + int old_refcount, + int new_refcount, + const char *why) +{ + static int enabled = -1; + + _dbus_trace_ref ("DBusServer", server, old_refcount, new_refcount, why, + "DBUS_SERVER_TRACE", &enabled); +} +#endif + /* this is a little fragile since it assumes the address doesn't * already have a guid, but it shouldn't */ @@ -98,11 +113,21 @@ _dbus_server_init_base (DBusServer *server, const DBusString *address) { server->vtable = vtable; - server->refcount.value = 1; + +#ifdef DBUS_DISABLE_ASSERT + _dbus_atomic_inc (&server->refcount); +#else + { + dbus_int32_t old_refcount = _dbus_atomic_inc (&server->refcount); + + _dbus_assert (old_refcount == 0); + } +#endif server->address = NULL; server->watches = NULL; server->timeouts = NULL; + server->published_address = FALSE; if (!_dbus_string_init (&server->guid_hex)) return FALSE; @@ -117,7 +142,7 @@ _dbus_server_init_base (DBusServer *server, if (server->address == NULL) goto failed; - _dbus_mutex_new_at_location (&server->mutex); + _dbus_rmutex_new_at_location (&server->mutex); if (server->mutex == NULL) goto failed; @@ -136,7 +161,7 @@ _dbus_server_init_base (DBusServer *server, return TRUE; failed: - _dbus_mutex_free_at_location (&server->mutex); + _dbus_rmutex_free_at_location (&server->mutex); server->mutex = NULL; if (server->watches) { @@ -183,7 +208,7 @@ _dbus_server_finalize_base (DBusServer *server) _dbus_watch_list_free (server->watches); _dbus_timeout_list_free (server->timeouts); - _dbus_mutex_free_at_location (&server->mutex); + _dbus_rmutex_free_at_location (&server->mutex); dbus_free (server->address); @@ -431,18 +456,15 @@ _dbus_server_toggle_timeout (DBusServer *server, void _dbus_server_ref_unlocked (DBusServer *server) { + dbus_int32_t old_refcount; + _dbus_assert (server != NULL); - _dbus_assert (server->refcount.value > 0); - HAVE_LOCK_CHECK (server); -#ifdef DBUS_HAVE_ATOMIC_INT - _dbus_atomic_inc (&server->refcount); -#else - _dbus_assert (server->refcount.value > 0); - - server->refcount.value += 1; -#endif + old_refcount = _dbus_atomic_inc (&server->refcount); + _dbus_assert (old_refcount > 0); + _dbus_server_trace_ref (server, old_refcount, old_refcount + 1, + "ref_unlocked"); } /** @@ -453,25 +475,21 @@ _dbus_server_ref_unlocked (DBusServer *server) void _dbus_server_unref_unlocked (DBusServer *server) { - dbus_bool_t last_unref; + dbus_int32_t old_refcount; /* Keep this in sync with dbus_server_unref */ - + _dbus_assert (server != NULL); - _dbus_assert (server->refcount.value > 0); HAVE_LOCK_CHECK (server); - -#ifdef DBUS_HAVE_ATOMIC_INT - last_unref = (_dbus_atomic_dec (&server->refcount) == 1); -#else - _dbus_assert (server->refcount.value > 0); - server->refcount.value -= 1; - last_unref = (server->refcount.value == 0); -#endif - - if (last_unref) + old_refcount = _dbus_atomic_dec (&server->refcount); + _dbus_assert (old_refcount > 0); + + _dbus_server_trace_ref (server, old_refcount, old_refcount - 1, + "unref_unlocked"); + + if (old_refcount == 1) { _dbus_assert (server->disconnected); @@ -511,7 +529,7 @@ static const struct { } listen_funcs[] = { { _dbus_server_listen_socket } , { _dbus_server_listen_platform_specific } -#ifdef DBUS_BUILD_TESTS +#ifdef DBUS_ENABLE_EMBEDDED_TESTS , { _dbus_server_listen_debug_pipe } #endif }; @@ -543,7 +561,7 @@ dbus_server_listen (const char *address, DBusServer *server; DBusAddressEntry **entries; int len, i; - DBusError first_connect_error; + DBusError first_connect_error = DBUS_ERROR_INIT; dbus_bool_t handled_once; _dbus_return_val_if_fail (address != NULL, NULL); @@ -553,9 +571,8 @@ dbus_server_listen (const char *address, return NULL; server = NULL; - dbus_error_init (&first_connect_error); handled_once = FALSE; - + for (i = 0; i < len; i++) { int j; @@ -563,9 +580,8 @@ dbus_server_listen (const char *address, for (j = 0; j < (int) _DBUS_N_ELEMENTS (listen_funcs); ++j) { DBusServerListenResult result; - DBusError tmp_error; - - dbus_error_init (&tmp_error); + DBusError tmp_error = DBUS_ERROR_INIT; + result = (* listen_funcs[j].func) (entries[i], &server, &tmp_error); @@ -577,6 +593,16 @@ dbus_server_listen (const char *address, handled_once = TRUE; goto out; } + else if (result == DBUS_SERVER_LISTEN_ADDRESS_ALREADY_USED) + { + _dbus_assert (server == NULL); + dbus_set_error (error, + DBUS_ERROR_ADDRESS_IN_USE, + "Address '%s' already used", + dbus_address_entry_get_method (entries[0])); + handled_once = TRUE; + goto out; + } else if (result == DBUS_SERVER_LISTEN_BAD_ADDRESS) { _dbus_assert (server == NULL); @@ -669,19 +695,25 @@ dbus_server_listen (const char *address, DBusServer * dbus_server_ref (DBusServer *server) { + dbus_int32_t old_refcount; + _dbus_return_val_if_fail (server != NULL, NULL); - _dbus_return_val_if_fail (server->refcount.value > 0, NULL); -#ifdef DBUS_HAVE_ATOMIC_INT - _dbus_atomic_inc (&server->refcount); -#else - SERVER_LOCK (server); - _dbus_assert (server->refcount.value > 0); + old_refcount = _dbus_atomic_inc (&server->refcount); - server->refcount.value += 1; - SERVER_UNLOCK (server); +#ifndef DBUS_DISABLE_CHECKS + if (_DBUS_UNLIKELY (old_refcount <= 0)) + { + _dbus_atomic_dec (&server->refcount); + _dbus_warn_check_failed (_dbus_return_if_fail_warning_format, + _DBUS_FUNCTION_NAME, "old_refcount > 0", + __FILE__, __LINE__); + return NULL; + } #endif + _dbus_server_trace_ref (server, old_refcount, old_refcount + 1, "ref"); + return server; } @@ -696,27 +728,35 @@ dbus_server_ref (DBusServer *server) void dbus_server_unref (DBusServer *server) { - dbus_bool_t last_unref; + dbus_int32_t old_refcount; /* keep this in sync with unref_unlocked */ - + _dbus_return_if_fail (server != NULL); - _dbus_return_if_fail (server->refcount.value > 0); -#ifdef DBUS_HAVE_ATOMIC_INT - last_unref = (_dbus_atomic_dec (&server->refcount) == 1); -#else - SERVER_LOCK (server); - - _dbus_assert (server->refcount.value > 0); + old_refcount = _dbus_atomic_dec (&server->refcount); - server->refcount.value -= 1; - last_unref = (server->refcount.value == 0); - - SERVER_UNLOCK (server); +#ifndef DBUS_DISABLE_CHECKS + if (_DBUS_UNLIKELY (old_refcount <= 0)) + { + /* undo side-effect first + * please do not try to simplify the code here by using + * _dbus_atomic_get(), why we don't use it is + * because it issues another atomic operation even though + * DBUS_DISABLE_CHECKS defined. + * Bug: https://bugs.freedesktop.org/show_bug.cgi?id=68303 + */ + _dbus_atomic_inc (&server->refcount); + _dbus_warn_check_failed (_dbus_return_if_fail_warning_format, + _DBUS_FUNCTION_NAME, "old_refcount > 0", + __FILE__, __LINE__); + return; + } #endif - - if (last_unref) + + _dbus_server_trace_ref (server, old_refcount, old_refcount - 1, "unref"); + + if (old_refcount == 1) { /* lock not held! */ _dbus_assert (server->disconnected); @@ -739,11 +779,10 @@ void dbus_server_disconnect (DBusServer *server) { _dbus_return_if_fail (server != NULL); - _dbus_return_if_fail (server->refcount.value > 0); + dbus_server_ref (server); SERVER_LOCK (server); - _dbus_server_ref_unlocked (server); - + _dbus_assert (server->vtable->disconnect != NULL); if (!server->disconnected) @@ -799,6 +838,43 @@ dbus_server_get_address (DBusServer *server) } /** + * Returns the unique ID of the server, as a newly-allocated + * string which must be freed by the caller. This ID is + * normally used by clients to tell when two #DBusConnection + * would be equivalent (because the server address passed + * to dbus_connection_open() will have the same guid in the + * two cases). dbus_connection_open() can re-use an existing + * connection with the same ID instead of opening a new + * connection. + * + * This is an ID unique to each #DBusServer. Remember that + * a #DBusServer represents only one mode of connecting, + * so e.g. a bus daemon can listen on multiple addresses + * which will mean it has multiple #DBusServer each with + * their own ID. + * + * The ID is not a UUID in the sense of RFC4122; the details + * are explained in the D-Bus specification. + * + * @param server the server + * @returns the id of the server or #NULL if no memory + */ +char* +dbus_server_get_id (DBusServer *server) +{ + char *retval; + + _dbus_return_val_if_fail (server != NULL, NULL); + + SERVER_LOCK (server); + retval = NULL; + _dbus_string_copy_data (&server->guid_hex, &retval); + SERVER_UNLOCK (server); + + return retval; +} + +/** * Sets a function to be used for handling new connections. The given * function is passed each new connection as the connection is * created. If the new connection function increments the connection's @@ -989,9 +1065,8 @@ dbus_server_set_auth_mechanisms (DBusServer *server, return TRUE; } - -static DBusDataSlotAllocator slot_allocator; -_DBUS_DEFINE_GLOBAL_LOCK (server_slots); +static DBusDataSlotAllocator slot_allocator = + _DBUS_DATA_SLOT_ALLOCATOR_INIT (_DBUS_LOCK_NAME (server_slots)); /** * Allocates an integer ID to be used for storing application-specific @@ -1011,7 +1086,6 @@ dbus_bool_t dbus_server_allocate_data_slot (dbus_int32_t *slot_p) { return _dbus_data_slot_allocator_alloc (&slot_allocator, - (DBusMutex **)&_DBUS_LOCK_NAME (server_slots), slot_p); } @@ -1108,8 +1182,9 @@ dbus_server_get_data (DBusServer *server, /** @} */ -#ifdef DBUS_BUILD_TESTS +#ifdef DBUS_ENABLE_EMBEDDED_TESTS #include "dbus-test.h" +#include dbus_bool_t _dbus_server_test (void) @@ -1129,11 +1204,10 @@ _dbus_server_test (void) for (i = 0; i < _DBUS_N_ELEMENTS (valid_addresses); i++) { - DBusError error; + DBusError error = DBUS_ERROR_INIT; + char *address; + char *id; - /* FIXME um, how are the two tests here different? */ - - dbus_error_init (&error); server = dbus_server_listen (valid_addresses[i], &error); if (server == NULL) { @@ -1142,18 +1216,21 @@ _dbus_server_test (void) _dbus_assert_not_reached ("Failed to listen for valid address."); } - dbus_server_disconnect (server); - dbus_server_unref (server); + id = dbus_server_get_id (server); + _dbus_assert (id != NULL); + address = dbus_server_get_address (server); + _dbus_assert (address != NULL); - /* Try disconnecting before unreffing */ - server = dbus_server_listen (valid_addresses[i], &error); - if (server == NULL) + if (strstr (address, id) == NULL) { - _dbus_warn ("server listen error: %s: %s\n", error.name, error.message); - dbus_error_free (&error); - _dbus_assert_not_reached ("Failed to listen for valid address."); + _dbus_warn ("server id '%s' is not in the server address '%s'\n", + id, address); + _dbus_assert_not_reached ("bad server id or address"); } + dbus_free (id); + dbus_free (address); + dbus_server_disconnect (server); dbus_server_unref (server); } @@ -1161,4 +1238,4 @@ _dbus_server_test (void) return TRUE; } -#endif /* DBUS_BUILD_TESTS */ +#endif /* DBUS_ENABLE_EMBEDDED_TESTS */