X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dbus%2Fdbus-server.c;h=3b9ee3414ed87e7aa673bf36391a0cf45d652fda;hb=d8155bf51bf6484a94e734601526bf211053a5e1;hp=be74ead0d6cb5888bc9c981420ae6f947d46370a;hpb=44ed933284589134603913b05f55ca55e8c5a566;p=platform%2Fupstream%2Fdbus.git diff --git a/dbus/dbus-server.c b/dbus/dbus-server.c index be74ead..3b9ee34 100644 --- a/dbus/dbus-server.c +++ b/dbus/dbus-server.c @@ -1,9 +1,9 @@ /* -*- mode: C; c-file-style: "gnu" -*- */ /* dbus-server.c DBusServer object * - * Copyright (C) 2002, 2003 Red Hat Inc. + * Copyright (C) 2002, 2003, 2004, 2005 Red Hat Inc. * - * Licensed under the Academic Free License version 1.2 + * Licensed under the Academic Free License version 2.1 * * 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 @@ -23,11 +23,13 @@ #include "dbus-server.h" #include "dbus-server-unix.h" +#include "dbus-server-socket.h" +#include "dbus-string.h" #ifdef DBUS_BUILD_TESTS -#include "dbus-server-debug.h" #include "dbus-server-debug-pipe.h" #endif #include "dbus-address.h" +#include "dbus-protocol.h" /** * @defgroup DBusServer DBusServer @@ -51,6 +53,37 @@ * @{ */ +/* this is a little fragile since it assumes the address doesn't + * already have a guid, but it shouldn't + */ +static char* +copy_address_with_guid_appended (const DBusString *address, + const DBusString *guid_hex) +{ + DBusString with_guid; + char *retval; + + if (!_dbus_string_init (&with_guid)) + return NULL; + + if (!_dbus_string_copy (address, 0, &with_guid, + _dbus_string_get_length (&with_guid)) || + !_dbus_string_append (&with_guid, ",guid=") || + !_dbus_string_copy (guid_hex, 0, + &with_guid, _dbus_string_get_length (&with_guid))) + { + _dbus_string_free (&with_guid); + return NULL; + } + + retval = NULL; + _dbus_string_steal_data (&with_guid, &retval); + + _dbus_string_free (&with_guid); + + return retval; /* may be NULL if steal_data failed */ +} + /** * Initializes the members of the DBusServer base class. * Chained up to by subclass constructors. @@ -66,14 +99,27 @@ _dbus_server_init_base (DBusServer *server, const DBusString *address) { server->vtable = vtable; - server->refcount = 1; + server->refcount.value = 1; server->address = NULL; server->watches = NULL; server->timeouts = NULL; - server->connection_counter = NULL; + + if (!_dbus_string_init (&server->guid_hex)) + return FALSE; + + _dbus_generate_uuid (&server->guid); + + if (!_dbus_uuid_encode (&server->guid, &server->guid_hex)) + goto failed; - if (!_dbus_string_copy_data (address, &server->address)) + server->address = copy_address_with_guid_appended (address, + &server->guid_hex); + if (server->address == NULL) + goto failed; + + _dbus_mutex_new_at_location (&server->mutex); + if (server->mutex == NULL) goto failed; server->watches = _dbus_watch_list_new (); @@ -83,12 +129,6 @@ _dbus_server_init_base (DBusServer *server, server->timeouts = _dbus_timeout_list_new (); if (server->timeouts == NULL) goto failed; - - server->connection_counter = _dbus_counter_new (); - if (server->connection_counter == NULL) - goto failed; - - server->max_connections = 256; /* same as an X server, seems like a nice default */ _dbus_data_slot_list_init (&server->slot_list); @@ -97,6 +137,8 @@ _dbus_server_init_base (DBusServer *server, return TRUE; failed: + _dbus_mutex_free_at_location (&server->mutex); + server->mutex = NULL; if (server->watches) { _dbus_watch_list_free (server->watches); @@ -107,16 +149,12 @@ _dbus_server_init_base (DBusServer *server, _dbus_timeout_list_free (server->timeouts); server->timeouts = NULL; } - if (server->connection_counter) - { - _dbus_counter_unref (server->connection_counter); - server->connection_counter = NULL; - } if (server->address) { dbus_free (server->address); server->address = NULL; } + _dbus_string_free (&server->guid_hex); return FALSE; } @@ -130,21 +168,86 @@ _dbus_server_init_base (DBusServer *server, void _dbus_server_finalize_base (DBusServer *server) { + /* We don't have the lock, but nobody should be accessing + * concurrently since they don't have a ref + */ +#ifndef DBUS_DISABLE_CHECKS + _dbus_assert (!server->have_server_lock); +#endif + _dbus_assert (server->disconnected); + /* calls out to application code... */ _dbus_data_slot_list_free (&server->slot_list); dbus_server_set_new_connection_function (server, NULL, NULL, NULL); - if (!server->disconnected) - dbus_server_disconnect (server); - _dbus_watch_list_free (server->watches); _dbus_timeout_list_free (server->timeouts); - _dbus_counter_unref (server->connection_counter); + _dbus_mutex_free_at_location (&server->mutex); + dbus_free (server->address); dbus_free_string_array (server->auth_mechanisms); + + _dbus_string_free (&server->guid_hex); +} + + +typedef dbus_bool_t (* DBusWatchAddFunction) (DBusWatchList *list, + DBusWatch *watch); +typedef void (* DBusWatchRemoveFunction) (DBusWatchList *list, + DBusWatch *watch); +typedef void (* DBusWatchToggleFunction) (DBusWatchList *list, + DBusWatch *watch, + dbus_bool_t enabled); + +static dbus_bool_t +protected_change_watch (DBusServer *server, + DBusWatch *watch, + DBusWatchAddFunction add_function, + DBusWatchRemoveFunction remove_function, + DBusWatchToggleFunction toggle_function, + dbus_bool_t enabled) +{ + DBusWatchList *watches; + dbus_bool_t retval; + + HAVE_LOCK_CHECK (server); + + /* This isn't really safe or reasonable; a better pattern is the "do + * everything, then drop lock and call out" one; but it has to be + * propagated up through all callers + */ + + watches = server->watches; + if (watches) + { + server->watches = NULL; + _dbus_server_ref_unlocked (server); + SERVER_UNLOCK (server); + + if (add_function) + retval = (* add_function) (watches, watch); + else if (remove_function) + { + retval = TRUE; + (* remove_function) (watches, watch); + } + else + { + retval = TRUE; + (* toggle_function) (watches, watch, enabled); + } + + SERVER_LOCK (server); + server->watches = watches; + _dbus_server_unref_unlocked (server); + + return retval; + } + else + return FALSE; } /** @@ -158,7 +261,10 @@ dbus_bool_t _dbus_server_add_watch (DBusServer *server, DBusWatch *watch) { - return _dbus_watch_list_add_watch (server->watches, watch); + HAVE_LOCK_CHECK (server); + return protected_change_watch (server, watch, + _dbus_watch_list_add_watch, + NULL, NULL, FALSE); } /** @@ -171,7 +277,11 @@ void _dbus_server_remove_watch (DBusServer *server, DBusWatch *watch) { - _dbus_watch_list_remove_watch (server->watches, watch); + HAVE_LOCK_CHECK (server); + protected_change_watch (server, watch, + NULL, + _dbus_watch_list_remove_watch, + NULL, FALSE); } /** @@ -188,9 +298,70 @@ _dbus_server_toggle_watch (DBusServer *server, DBusWatch *watch, dbus_bool_t enabled) { - if (server->watches) /* null during finalize */ - _dbus_watch_list_toggle_watch (server->watches, - watch, enabled); + _dbus_assert (watch != NULL); + + HAVE_LOCK_CHECK (server); + protected_change_watch (server, watch, + NULL, NULL, + _dbus_watch_list_toggle_watch, + enabled); +} + + +typedef dbus_bool_t (* DBusTimeoutAddFunction) (DBusTimeoutList *list, + DBusTimeout *timeout); +typedef void (* DBusTimeoutRemoveFunction) (DBusTimeoutList *list, + DBusTimeout *timeout); +typedef void (* DBusTimeoutToggleFunction) (DBusTimeoutList *list, + DBusTimeout *timeout, + dbus_bool_t enabled); + + +static dbus_bool_t +protected_change_timeout (DBusServer *server, + DBusTimeout *timeout, + DBusTimeoutAddFunction add_function, + DBusTimeoutRemoveFunction remove_function, + DBusTimeoutToggleFunction toggle_function, + dbus_bool_t enabled) +{ + DBusTimeoutList *timeouts; + dbus_bool_t retval; + + HAVE_LOCK_CHECK (server); + + /* This isn't really safe or reasonable; a better pattern is the "do everything, then + * drop lock and call out" one; but it has to be propagated up through all callers + */ + + timeouts = server->timeouts; + if (timeouts) + { + server->timeouts = NULL; + _dbus_server_ref_unlocked (server); + SERVER_UNLOCK (server); + + if (add_function) + retval = (* add_function) (timeouts, timeout); + else if (remove_function) + { + retval = TRUE; + (* remove_function) (timeouts, timeout); + } + else + { + retval = TRUE; + (* toggle_function) (timeouts, timeout, enabled); + } + + SERVER_LOCK (server); + server->timeouts = timeouts; + _dbus_server_unref_unlocked (server); + + return retval; + } + else + return FALSE; } /** @@ -206,7 +377,9 @@ dbus_bool_t _dbus_server_add_timeout (DBusServer *server, DBusTimeout *timeout) { - return _dbus_timeout_list_add_timeout (server->timeouts, timeout); + return protected_change_timeout (server, timeout, + _dbus_timeout_list_add_timeout, + NULL, NULL, FALSE); } /** @@ -219,7 +392,10 @@ void _dbus_server_remove_timeout (DBusServer *server, DBusTimeout *timeout) { - _dbus_timeout_list_remove_timeout (server->timeouts, timeout); + protected_change_timeout (server, timeout, + NULL, + _dbus_timeout_list_remove_timeout, + NULL, FALSE); } /** @@ -236,12 +412,12 @@ _dbus_server_toggle_timeout (DBusServer *server, DBusTimeout *timeout, dbus_bool_t enabled) { - if (server->timeouts) /* null during finalize */ - _dbus_timeout_list_toggle_timeout (server->timeouts, - timeout, enabled); + protected_change_timeout (server, timeout, + NULL, NULL, + _dbus_timeout_list_toggle_timeout, + enabled); } - /** @} */ /** @@ -263,17 +439,30 @@ _dbus_server_toggle_timeout (DBusServer *server, * */ +static const struct { + DBusServerListenResult (* func) (DBusAddressEntry *entry, + DBusServer **server_p, + DBusError *error); +} listen_funcs[] = { + { _dbus_server_listen_socket }, + { _dbus_server_listen_platform_specific } +#ifdef DBUS_BUILD_TESTS + , { _dbus_server_listen_debug_pipe } +#endif +}; + /** * Listens for new connections on the given address. - * Returns #NULL if listening fails for any reason. + * If there are multiple address entries in the address, + * tries each one and listens on the first one that + * works. + * + * Returns #NULL and sets error if listening fails for any reason. * Otherwise returns a new #DBusServer. * dbus_server_set_new_connection_function() and * dbus_server_set_watch_functions() should be called * immediately to render the server fully functional. - * - * @todo error messages on bad address could really be better. - * DBusResultCode is a bit limiting here. - * + * * @param address the address of this server. * @param error location to store rationale for failure. * @returns a new DBusServer, or #NULL on failure. @@ -286,156 +475,240 @@ dbus_server_listen (const char *address, DBusServer *server; DBusAddressEntry **entries; int len, i; - const char *address_problem_type; - const char *address_problem_field; - const char *address_problem_other; - - _DBUS_ASSERT_ERROR_IS_CLEAR (error); + DBusError first_connect_error; + dbus_bool_t handled_once; + + _dbus_return_val_if_fail (address != NULL, NULL); + _dbus_return_val_if_error_is_set (error, NULL); if (!dbus_parse_address (address, &entries, &len, error)) return NULL; server = NULL; - address_problem_type = NULL; - address_problem_field = NULL; - address_problem_other = NULL; + dbus_error_init (&first_connect_error); + handled_once = FALSE; for (i = 0; i < len; i++) { - const char *method = dbus_address_entry_get_method (entries[i]); + int j; - if (strcmp (method, "unix") == 0) - { - const char *path = dbus_address_entry_get_value (entries[i], "path"); + for (j = 0; j < (int) _DBUS_N_ELEMENTS (listen_funcs); ++j) + { + DBusServerListenResult result; + DBusError tmp_error; + + dbus_error_init (&tmp_error); + result = (* listen_funcs[j].func) (entries[i], + &server, + &tmp_error); - if (path == NULL) + if (result == DBUS_SERVER_LISTEN_OK) { - address_problem_type = "unix"; - address_problem_field = "path"; - goto bad_address; + _dbus_assert (server != NULL); + _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error); + handled_once = TRUE; + goto out; } - - server = _dbus_server_new_for_domain_socket (path, error); - - if (server) - break; - } - else if (strcmp (method, "tcp") == 0) - { - const char *host = dbus_address_entry_get_value (entries[i], "host"); - const char *port = dbus_address_entry_get_value (entries[i], "port"); - DBusString str; - long lport; - dbus_bool_t sresult; - - if (port == NULL) + else if (result == DBUS_SERVER_LISTEN_BAD_ADDRESS) { - address_problem_type = "tcp"; - address_problem_field = "port"; - goto bad_address; + _dbus_assert (server == NULL); + _DBUS_ASSERT_ERROR_IS_SET (&tmp_error); + dbus_move_error (&tmp_error, error); + handled_once = TRUE; + goto out; } - - _dbus_string_init_const (&str, port); - sresult = _dbus_string_parse_int (&str, 0, &lport, NULL); - _dbus_string_free (&str); - - if (sresult == FALSE || lport <= 0 || lport > 65535) + else if (result == DBUS_SERVER_LISTEN_NOT_HANDLED) { - address_problem_other = "Port is not an integer between 0 and 65535"; - goto bad_address; - } - - server = _dbus_server_new_for_tcp_socket (host, lport, error); - - if (server) - break; - } -#ifdef DBUS_BUILD_TESTS - else if (strcmp (method, "debug") == 0) - { - const char *name = dbus_address_entry_get_value (entries[i], "name"); + _dbus_assert (server == NULL); + _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error); - if (name == NULL) - { - address_problem_type = "debug"; - address_problem_field = "name"; - goto bad_address; + /* keep trying addresses */ } - - server = _dbus_server_debug_new (name, error); - - if (server) - break; - } - else if (strcmp (method, "debug-pipe") == 0) - { - const char *name = dbus_address_entry_get_value (entries[i], "name"); - - if (name == NULL) + else if (result == DBUS_SERVER_LISTEN_DID_NOT_CONNECT) { - address_problem_type = "debug-pipe"; - address_problem_field = "name"; - goto bad_address; + _dbus_assert (server == NULL); + _DBUS_ASSERT_ERROR_IS_SET (&tmp_error); + if (!dbus_error_is_set (&first_connect_error)) + dbus_move_error (&tmp_error, &first_connect_error); + else + dbus_error_free (&tmp_error); + + handled_once = TRUE; + + /* keep trying addresses */ } + } - server = _dbus_server_debug_pipe_new (name, error); + _dbus_assert (server == NULL); + _DBUS_ASSERT_ERROR_IS_CLEAR (error); + } - if (server) - break; - } -#endif + out: + + if (!handled_once) + { + _DBUS_ASSERT_ERROR_IS_CLEAR (error); + if (len > 0) + dbus_set_error (error, + DBUS_ERROR_BAD_ADDRESS, + "Unknown address type '%s'", + dbus_address_entry_get_method (entries[0])); else - { - address_problem_other = "Unknown address type (examples of valid types are \"unix\" and \"tcp\")"; - goto bad_address; - } + dbus_set_error (error, + DBUS_ERROR_BAD_ADDRESS, + "Empty address '%s'", + address); } dbus_address_entries_free (entries); - return server; - bad_address: - dbus_address_entries_free (entries); - if (address_problem_type != NULL) - dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS, - "Server address of type %s was missing argument %s", - address_problem_type, address_problem_field); - else - dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS, - "Could not parse server address: %s", - address_problem_other); + if (server == NULL) + { + _dbus_assert (error == NULL || dbus_error_is_set (&first_connect_error) || + dbus_error_is_set (error)); + + if (error && dbus_error_is_set (error)) + { + /* already set the error */ + } + else + { + /* didn't set the error but either error should be + * NULL or first_connect_error should be set. + */ + _dbus_assert (error == NULL || dbus_error_is_set (&first_connect_error)); + dbus_move_error (&first_connect_error, error); + } + + _DBUS_ASSERT_ERROR_IS_CLEAR (&first_connect_error); /* be sure we freed it */ + _DBUS_ASSERT_ERROR_IS_SET (error); - return NULL; + return NULL; + } + else + { + _DBUS_ASSERT_ERROR_IS_CLEAR (error); + return server; + } } /** * Increments the reference count of a DBusServer. * * @param server the server. + * @returns the server */ -void +DBusServer * dbus_server_ref (DBusServer *server) { - server->refcount += 1; + _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); + + server->refcount.value += 1; + SERVER_UNLOCK (server); +#endif + + return server; } /** * Decrements the reference count of a DBusServer. Finalizes the - * server if the reference count reaches zero. The server connection - * will be closed as with dbus_server_disconnect() when the server is - * finalized. + * server if the reference count reaches zero. + * + * The server must be disconnected before the refcount reaches zero. * * @param server the server. */ void dbus_server_unref (DBusServer *server) { + dbus_bool_t last_unref; + + _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); + + server->refcount.value -= 1; + last_unref = (server->refcount.value == 0); + + SERVER_UNLOCK (server); +#endif + + if (last_unref) + { + /* lock not held! */ + _dbus_assert (server->disconnected); + + _dbus_assert (server->vtable->finalize != NULL); + + (* server->vtable->finalize) (server); + } +} + +/** + * Like dbus_server_ref() but does not acquire the lock (must already be held) + * + * @param server the server. + */ +void +_dbus_server_ref_unlocked (DBusServer *server) +{ _dbus_assert (server != NULL); - _dbus_assert (server->refcount > 0); + _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 +} - server->refcount -= 1; - if (server->refcount == 0) +/** + * Like dbus_server_unref() but does not acquire the lock (must already be held) + * + * @param server the server. + */ +void +_dbus_server_unref_unlocked (DBusServer *server) +{ + dbus_bool_t last_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) { + _dbus_assert (server->disconnected); + + SERVER_UNLOCK (server); + _dbus_assert (server->vtable->finalize != NULL); (* server->vtable->finalize) (server); @@ -453,13 +726,24 @@ dbus_server_unref (DBusServer *server) void dbus_server_disconnect (DBusServer *server) { - _dbus_assert (server->vtable->disconnect != NULL); + _dbus_return_if_fail (server != NULL); + _dbus_return_if_fail (server->refcount.value > 0); - if (server->disconnected) - return; + SERVER_LOCK (server); + _dbus_server_ref_unlocked (server); - (* server->vtable->disconnect) (server); - server->disconnected = TRUE; + _dbus_assert (server->vtable->disconnect != NULL); + + if (!server->disconnected) + { + /* this has to be first so recursive calls to disconnect don't happen */ + server->disconnected = TRUE; + + (* server->vtable->disconnect) (server); + } + + SERVER_UNLOCK (server); + dbus_server_unref (server); } /** @@ -470,7 +754,15 @@ dbus_server_disconnect (DBusServer *server) dbus_bool_t dbus_server_get_is_connected (DBusServer *server) { - return !server->disconnected; + dbus_bool_t retval; + + _dbus_return_val_if_fail (server != NULL, FALSE); + + SERVER_LOCK (server); + retval = !server->disconnected; + SERVER_UNLOCK (server); + + return retval; } /** @@ -483,7 +775,15 @@ dbus_server_get_is_connected (DBusServer *server) char* dbus_server_get_address (DBusServer *server) { - return _dbus_strdup (server->address); + char *retval; + + _dbus_return_val_if_fail (server != NULL, NULL); + + SERVER_LOCK (server); + retval = _dbus_strdup (server->address); + SERVER_UNLOCK (server); + + return retval; } /** @@ -504,12 +804,22 @@ dbus_server_set_new_connection_function (DBusServer *server, void *data, DBusFreeFunction free_data_function) { - if (server->new_connection_free_data_function != NULL) - (* server->new_connection_free_data_function) (server->new_connection_data); + DBusFreeFunction old_free_function; + void *old_data; + + _dbus_return_if_fail (server != NULL); + + SERVER_LOCK (server); + old_free_function = server->new_connection_free_data_function; + old_data = server->new_connection_data; server->new_connection_function = function; server->new_connection_data = data; server->new_connection_free_data_function = free_data_function; + SERVER_UNLOCK (server); + + if (old_free_function != NULL) + (* old_free_function) (old_data); } /** @@ -536,12 +846,34 @@ dbus_server_set_watch_functions (DBusServer *server, void *data, DBusFreeFunction free_data_function) { - return _dbus_watch_list_set_functions (server->watches, - add_function, - remove_function, - toggled_function, - data, - free_data_function); + dbus_bool_t result; + DBusWatchList *watches; + + _dbus_return_val_if_fail (server != NULL, FALSE); + + SERVER_LOCK (server); + watches = server->watches; + server->watches = NULL; + if (watches) + { + SERVER_UNLOCK (server); + result = _dbus_watch_list_set_functions (watches, + add_function, + remove_function, + toggled_function, + data, + free_data_function); + SERVER_LOCK (server); + } + else + { + _dbus_warn ("Re-entrant call to %s\n", _DBUS_FUNCTION_NAME); + result = FALSE; + } + server->watches = watches; + SERVER_UNLOCK (server); + + return result; } /** @@ -567,38 +899,34 @@ dbus_server_set_timeout_functions (DBusServer *server, void *data, DBusFreeFunction free_data_function) { - return _dbus_timeout_list_set_functions (server->timeouts, - add_function, remove_function, - toggled_function, - data, free_data_function); -} - -/** - * Called to notify the server when a previously-added watch - * is ready for reading or writing, or has an exception such - * as a hangup. - * - * If this function returns #FALSE, then the file descriptor may still - * be ready for reading or writing, but more memory is needed in order - * to do the reading or writing. If you ignore the #FALSE return, your - * application may spin in a busy loop on the file descriptor until - * memory becomes available, but nothing more catastrophic should - * happen. - * - * @param server the server. - * @param watch the watch. - * @param condition the current condition of the file descriptors being watched. - */ -dbus_bool_t -dbus_server_handle_watch (DBusServer *server, - DBusWatch *watch, - unsigned int condition) -{ - _dbus_assert (server->vtable->handle_watch != NULL); + dbus_bool_t result; + DBusTimeoutList *timeouts; + + _dbus_return_val_if_fail (server != NULL, FALSE); - _dbus_watch_sanitize_condition (watch, &condition); + SERVER_LOCK (server); + timeouts = server->timeouts; + server->timeouts = NULL; + if (timeouts) + { + SERVER_UNLOCK (server); + result = _dbus_timeout_list_set_functions (timeouts, + add_function, + remove_function, + toggled_function, + data, + free_data_function); + SERVER_LOCK (server); + } + else + { + _dbus_warn ("Re-entrant call to %s\n", _DBUS_FUNCTION_NAME); + result = FALSE; + } + server->timeouts = timeouts; + SERVER_UNLOCK (server); - return (* server->vtable->handle_watch) (server, watch, condition); + return result; } /** @@ -617,6 +945,10 @@ dbus_server_set_auth_mechanisms (DBusServer *server, { char **copy; + _dbus_return_val_if_fail (server != NULL, FALSE); + + SERVER_LOCK (server); + if (mechanisms != NULL) { copy = _dbus_dup_string_array (mechanisms); @@ -629,74 +961,11 @@ dbus_server_set_auth_mechanisms (DBusServer *server, dbus_free_string_array (server->auth_mechanisms); server->auth_mechanisms = copy; + SERVER_UNLOCK (server); + return TRUE; } -/** - * Sets the maximum number of connections that can be open at one - * time for this server. If the maximum is reached, and another - * client tries to connect, then the oldest unauthenticated client - * will be dropped. If no unauthenticated client exists, then - * the new connection will be refused. - * - * If the maximum is set to a number lower than the current - * number of connections, no current connections are - * disconnected. - * - * @todo honoring max_connections has not been implemented - * yet. The only real work involved is keeping a list - * of live connections on the DBusServer so the oldest - * unauthenticated client can be located when required. - * - * @todo for a systemwide daemon, we need a max number of connections - * per user, since any user can authenticate a bunch of connections - * and create a DOS. - * - * @todo a single process might listen on multiple mechanisms - * (multiple DBusServer) and might want the max connections - * value to span all those servers. Should consider - * changing the API accordingly, though I'm inclined to - * punt this to the app that wants to do it instead of - * putting it in the library. - * - * @param server the server - * @param max_connections maximum number of connections allowed - */ -void -dbus_server_set_max_connections (DBusServer *server, - int max_connections) -{ - server->max_connections = max_connections; -} - -/** - * Gets the maximum number of connections that can be active - * at a time for this server. - * - * @param server the server - * @returns maximum number of connections at once - */ -int -dbus_server_get_max_connections (DBusServer *server) -{ - return server->max_connections; -} - -/** - * Gets the number of #DBusConnection to this server that - * have not yet been finalized. i.e. all #DBusConnection that - * were passed to #DBusNewConnectionFunction and have not yet been - * finalized will count in this total. - * - * @param server the server - * @returns the number of connections - */ -int -dbus_server_get_n_connections (DBusServer *server) -{ - return _dbus_counter_get_value (server->connection_counter); -} - static DBusDataSlotAllocator slot_allocator; _DBUS_DEFINE_GLOBAL_LOCK (server_slots); @@ -705,17 +974,22 @@ _DBUS_DEFINE_GLOBAL_LOCK (server_slots); * Allocates an integer ID to be used for storing application-specific * data on any DBusServer. The allocated ID may then be used * with dbus_server_set_data() and dbus_server_get_data(). - * If allocation fails, -1 is returned. Again, the allocated - * slot is global, i.e. all DBusServer objects will - * have a slot with the given integer ID reserved. + * The slot must be initialized with -1. If a nonnegative + * slot is passed in, the refcount is incremented on that + * slot, rather than creating a new slot. + * + * The allocated slot is global, i.e. all DBusServer objects will have + * a slot with the given integer ID reserved. * - * @returns -1 on failure, otherwise the data slot ID + * @param slot_p address of global variable storing the slot ID + * @returns #FALSE on no memory */ -int -dbus_server_allocate_data_slot (void) +dbus_bool_t +dbus_server_allocate_data_slot (dbus_int32_t *slot_p) { return _dbus_data_slot_allocator_alloc (&slot_allocator, - _DBUS_LOCK_NAME (server_slots)); + (DBusMutex **)&_DBUS_LOCK_NAME (server_slots), + slot_p); } /** @@ -727,12 +1001,14 @@ dbus_server_allocate_data_slot (void) * but may not be retrieved (and may only be replaced * if someone else reallocates the slot). * - * @param slot the slot to deallocate + * @param slot_p address of the slot to deallocate */ void -dbus_server_free_data_slot (int slot) +dbus_server_free_data_slot (dbus_int32_t *slot_p) { - _dbus_data_slot_allocator_free (&slot_allocator, slot); + _dbus_return_if_fail (*slot_p >= 0); + + _dbus_data_slot_allocator_free (&slot_allocator, slot_p); } /** @@ -749,7 +1025,7 @@ dbus_server_free_data_slot (int slot) * @returns #TRUE if there was enough memory to store the data */ dbus_bool_t -dbus_server_set_data (DBusServer *server, +dbus_server_set_data (DBusServer *server, int slot, void *data, DBusFreeFunction free_data_func) @@ -758,18 +1034,17 @@ dbus_server_set_data (DBusServer *server, void *old_data; dbus_bool_t retval; -#if 0 - dbus_mutex_lock (server->mutex); -#endif + _dbus_return_val_if_fail (server != NULL, FALSE); + + SERVER_LOCK (server); retval = _dbus_data_slot_list_set (&slot_allocator, &server->slot_list, slot, data, free_data_func, &old_free_func, &old_data); -#if 0 - dbus_mutex_unlock (server->mutex); -#endif + + SERVER_UNLOCK (server); if (retval) { @@ -791,24 +1066,74 @@ dbus_server_set_data (DBusServer *server, */ void* dbus_server_get_data (DBusServer *server, - int slot) + int slot) { void *res; + + _dbus_return_val_if_fail (server != NULL, NULL); -#if 0 - dbus_mutex_lock (server->mutex); -#endif + SERVER_LOCK (server); res = _dbus_data_slot_list_get (&slot_allocator, &server->slot_list, slot); -#if 0 - dbus_mutex_unlock (server->mutex); -#endif + SERVER_UNLOCK (server); return res; } /** @} */ +#ifdef DBUS_BUILD_TESTS +#include "dbus-test.h" + +dbus_bool_t +_dbus_server_test (void) +{ + const char *valid_addresses[] = { + "tcp:port=1234", + "unix:path=./boogie", + "tcp:host=localhost,port=1234", + "tcp:host=localhost,port=1234;tcp:port=5678", + "tcp:port=1234;unix:path=./boogie", + }; + + DBusServer *server; + int i; + + for (i = 0; i < _DBUS_N_ELEMENTS (valid_addresses); i++) + { + DBusError error; + + /* FIXME um, how are the two tests here different? */ + + dbus_error_init (&error); + server = dbus_server_listen (valid_addresses[i], &error); + if (server == 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_server_disconnect (server); + dbus_server_unref (server); + + /* Try disconnecting before unreffing */ + server = dbus_server_listen (valid_addresses[i], &error); + if (server == 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_server_disconnect (server); + dbus_server_unref (server); + } + + return TRUE; +} + +#endif /* DBUS_BUILD_TESTS */