#include <config.h>
#include "dbus-bus.h"
-#include "dbus-config.h"
#include "dbus-protocol.h"
#include "dbus-internals.h"
#include "dbus-message.h"
#include "dbus-threads-internal.h"
#include "dbus-connection-internal.h"
#include "dbus-string.h"
+#include "dbus-transport-kdbus.h"
+
/**
* @defgroup DBusBus Message bus APIs
static dbus_bool_t initialized = FALSE;
-/**
- * Lock for globals in this file
- */
-_DBUS_DEFINE_GLOBAL_LOCK (bus);
-
-/**
- * Global lock covering all BusData on any connection. The bet is
- * that some lock contention is better than more memory
- * for a per-connection lock, but it's tough to imagine it mattering
- * either way.
- */
-_DBUS_DEFINE_GLOBAL_LOCK (bus_datas);
-
static void
addresses_shutdown_func (void *data)
{
if (!retval)
return FALSE;
- /* The DBUS_SESSION_BUS_DEFAULT_ADDRESS should have really been named
- * DBUS_SESSION_BUS_FALLBACK_ADDRESS.
- */
+ /* We have a hard-coded (but compile-time-configurable) fallback address for
+ * the session bus. */
if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
bus_connection_addresses[DBUS_BUS_SESSION] =
- _dbus_strdup (DBUS_SESSION_BUS_DEFAULT_ADDRESS);
+ _dbus_strdup (DBUS_SESSION_BUS_CONNECT_ADDRESS);
+
if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
return FALSE;
if (bus_connection_addresses[DBUS_BUS_STARTER] != NULL)
{
- s = _dbus_config_starter_bus_type();
+ s = _dbus_getenv ("DBUS_STARTER_BUS_TYPE");
if (s != NULL)
{
if (bd->is_well_known)
{
int i;
- _DBUS_LOCK (bus);
+
+ if (!_DBUS_LOCK (bus))
+ _dbus_assert_not_reached ("global locks should have been initialized "
+ "when we attached bus data");
+
/* We may be stored in more than one slot */
/* This should now be impossible - these slots are supposed to
* be cleared on disconnect, so should not need to be cleared on
_dbus_bus_notify_shared_connection_disconnected_unlocked (DBusConnection *connection)
{
int i;
-
- _DBUS_LOCK (bus);
+
+ if (!_DBUS_LOCK (bus))
+ {
+ /* If it was in bus_connections, we would have initialized global locks
+ * when we added it. So, it can't be. */
+ return;
+ }
/* We are expecting to have the connection saved in only one of these
* slots, but someone could in a pathological case set system and session
_dbus_return_val_if_fail (type >= 0 && type < N_BUS_TYPES, NULL);
_dbus_return_val_if_error_is_set (error, NULL);
- _DBUS_LOCK (bus);
+ connection = NULL;
- if (!init_connections_unlocked ())
+ if (!_DBUS_LOCK (bus))
{
- _DBUS_UNLOCK (bus);
_DBUS_SET_OOM (error);
+ /* do not "goto out", that would try to unlock */
return NULL;
}
+ if (!init_connections_unlocked ())
+ {
+ _DBUS_SET_OOM (error);
+ goto out;
+ }
+
/* We want to use the activation address even if the
* activating bus is the session or system bus,
* per the spec.
{
connection = bus_connections[type];
dbus_connection_ref (connection);
-
- _DBUS_UNLOCK (bus);
- return connection;
+ goto out;
}
address = bus_connection_addresses[address_type];
{
dbus_set_error (error, DBUS_ERROR_FAILED,
"Unable to determine the address of the message bus (try 'man dbus-launch' and 'man dbus-daemon' for help)");
- _DBUS_UNLOCK (bus);
- return NULL;
+ goto out;
}
if (private)
if (!connection)
{
- _DBUS_ASSERT_ERROR_IS_SET (error);
- _DBUS_UNLOCK (bus);
- return NULL;
+ goto out;
}
+ _dbus_verbose (" !!! dbus_connection_open finished successfully !!!! \n"); //todo RP to be removed
+
if (!dbus_bus_register (connection, error))
{
- _DBUS_ASSERT_ERROR_IS_SET (error);
_dbus_connection_close_possibly_shared (connection);
dbus_connection_unref (connection);
-
- _DBUS_UNLOCK (bus);
- return NULL;
+ connection = NULL;
+ goto out;
}
if (!private)
*/
dbus_connection_set_exit_on_disconnect (connection,
TRUE);
-
- _DBUS_LOCK (bus_datas);
+
+ if (!_DBUS_LOCK (bus_datas))
+ _dbus_assert_not_reached ("global locks were initialized already");
+
bd = ensure_bus_data (connection);
_dbus_assert (bd != NULL); /* it should have been created on
register, so OOM not possible */
bd->is_well_known = TRUE;
_DBUS_UNLOCK (bus_datas);
-
- _DBUS_UNLOCK (bus);
+out:
+ /* Return a reference to the caller, or NULL with error set. */
+ if (connection == NULL)
+ _DBUS_ASSERT_ERROR_IS_SET (error);
- /* Return a reference to the caller */
+ _DBUS_UNLOCK (bus);
return connection;
}
DBusError *error)
{
DBusMessage *message, *reply;
- char *name;
+ char name[18];
BusData *bd;
dbus_bool_t retval;
_dbus_return_val_if_error_is_set (error, FALSE);
retval = FALSE;
+ message = NULL;
+ reply = NULL;
- _DBUS_LOCK (bus_datas);
+ if (!_DBUS_LOCK (bus_datas))
+ {
+ _DBUS_SET_OOM (error);
+ /* do not "goto out", that would try to unlock */
+ return FALSE;
+ }
bd = ensure_bus_data (connection);
if (bd == NULL)
{
_DBUS_SET_OOM (error);
- _DBUS_UNLOCK (bus_datas);
- return FALSE;
+ goto out;
}
if (bd->unique_name != NULL)
{
_dbus_verbose ("Ignoring attempt to register the same DBusConnection %s with the message bus a second time.\n",
bd->unique_name);
- _DBUS_UNLOCK (bus_datas);
-
/* Success! */
- return TRUE;
+ retval = TRUE;
+ goto out;
}
-
- message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
- DBUS_PATH_DBUS,
- DBUS_INTERFACE_DBUS,
- "Hello");
+ if(dbus_transport_is_kdbus(connection))
+ {
+ if(!bus_register_kdbus(name, connection, error))
+ goto out;
- if (!message)
- {
- _DBUS_SET_OOM (error);
+ if(!bus_register_policy_kdbus(name, connection, error))
+ goto out;
- _DBUS_UNLOCK (bus_datas);
- return FALSE;
- }
-
- reply = dbus_connection_send_with_reply_and_block (connection, message, -1, error);
+ dbus_connection_set_is_authenticated(connection);
+ }
+ else
+ {
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "Hello");
+
+ if (!message)
+ {
+ _DBUS_SET_OOM (error);
+ goto out;
+ }
+
+ reply = dbus_connection_send_with_reply_and_block (connection, message, -1, error);
+
+ if (reply == NULL)
+ goto out;
+ else if (dbus_set_error_from_message (error, reply))
+ goto out;
+ else if (!dbus_message_get_args (reply, error,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID))
+ goto out;
+ }
- dbus_message_unref (message);
-
- if (reply == NULL)
- goto out;
- else if (dbus_set_error_from_message (error, reply))
- goto out;
- else if (!dbus_message_get_args (reply, error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID))
- goto out;
-
bd->unique_name = _dbus_strdup (name);
if (bd->unique_name == NULL)
{
_DBUS_SET_OOM (error);
goto out;
}
-
+ //_dbus_verbose("-- Our uniqe name is: %s\n", bd->unique_name);
retval = TRUE;
out:
+ _DBUS_UNLOCK (bus_datas);
+
+ if (message)
+ dbus_message_unref (message);
+
if (reply)
dbus_message_unref (reply);
if (!retval)
_DBUS_ASSERT_ERROR_IS_SET (error);
- _DBUS_UNLOCK (bus_datas);
-
return retval;
}
const char *unique_name)
{
BusData *bd;
- dbus_bool_t success;
+ dbus_bool_t success = FALSE;
_dbus_return_val_if_fail (connection != NULL, FALSE);
_dbus_return_val_if_fail (unique_name != NULL, FALSE);
- _DBUS_LOCK (bus_datas);
-
+ if (!_DBUS_LOCK (bus_datas))
+ {
+ /* do not "goto out", that would try to unlock */
+ return FALSE;
+ }
+
bd = ensure_bus_data (connection);
if (bd == NULL)
- return FALSE;
+ goto out;
_dbus_assert (bd->unique_name == NULL);
bd->unique_name = _dbus_strdup (unique_name);
success = bd->unique_name != NULL;
-
+
+out:
_DBUS_UNLOCK (bus_datas);
return success;
dbus_bus_get_unique_name (DBusConnection *connection)
{
BusData *bd;
- const char *unique_name;
+ const char *unique_name = NULL;
_dbus_return_val_if_fail (connection != NULL, NULL);
- _DBUS_LOCK (bus_datas);
-
+ if (!_DBUS_LOCK (bus_datas))
+ {
+ /* We'd have initialized locks when we gave it its unique name, if it
+ * had one. Don't "goto out", that would try to unlock. */
+ return NULL;
+ }
+
bd = ensure_bus_data (connection);
if (bd == NULL)
- return NULL;
+ goto out;
unique_name = bd->unique_name;
+out:
_DBUS_UNLOCK (bus_datas);
-
+
return unique_name;
}
unsigned int flags,
DBusError *error)
{
- DBusMessage *message, *reply;
- dbus_uint32_t result;
-
- _dbus_return_val_if_fail (connection != NULL, 0);
- _dbus_return_val_if_fail (name != NULL, 0);
- _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), 0);
- _dbus_return_val_if_error_is_set (error, 0);
-
- message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
- DBUS_PATH_DBUS,
- DBUS_INTERFACE_DBUS,
- "RequestName");
-
- if (message == NULL)
- {
- _DBUS_SET_OOM (error);
- return -1;
- }
-
- if (!dbus_message_append_args (message,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_UINT32, &flags,
- DBUS_TYPE_INVALID))
- {
- dbus_message_unref (message);
- _DBUS_SET_OOM (error);
- return -1;
- }
-
- reply = dbus_connection_send_with_reply_and_block (connection, message, -1,
- error);
-
- dbus_message_unref (message);
-
- if (reply == NULL)
- {
- _DBUS_ASSERT_ERROR_IS_SET (error);
- return -1;
- }
-
- if (dbus_set_error_from_message (error, reply))
- {
- _DBUS_ASSERT_ERROR_IS_SET (error);
- dbus_message_unref (reply);
- return -1;
- }
+ dbus_uint32_t result;
+
+ _dbus_return_val_if_fail (connection != NULL, 0);
+ _dbus_return_val_if_fail (name != NULL, 0);
+ _dbus_return_val_if_fail (_dbus_check_is_valid_bus_name (name), 0);
+ _dbus_return_val_if_error_is_set (error, 0);
+
+ if(!dbus_transport_is_kdbus(connection))
+ {
+ DBusMessage *message, *reply;
+
+ message = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "RequestName");
+ if (message == NULL)
+ {
+ _DBUS_SET_OOM (error);
+ return -1;
+ }
+
+ if (!dbus_message_append_args (message,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_UINT32, &flags,
+ DBUS_TYPE_INVALID))
+ {
+ dbus_message_unref (message);
+ _DBUS_SET_OOM (error);
+ return -1;
+ }
+
+ reply = dbus_connection_send_with_reply_and_block (connection, message, -1,
+ error);
+
+ dbus_message_unref (message);
+
+ if (reply == NULL)
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return -1;
+ }
+
+ if (dbus_set_error_from_message (error, reply))
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ dbus_message_unref (reply);
+ return -1;
+ }
+
+ if (!dbus_message_get_args (reply, error,
+ DBUS_TYPE_UINT32, &result,
+ DBUS_TYPE_INVALID))
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ dbus_message_unref (reply);
+ return -1;
+ }
+
+ dbus_message_unref (reply);
+ }
+ else
+ {
+ if(!bus_register_policy_kdbus(name, connection, error))
+ return -1;
+
+ result = bus_request_name_kdbus(connection, name, flags, error);
+ }
- if (!dbus_message_get_args (reply, error,
- DBUS_TYPE_UINT32, &result,
- DBUS_TYPE_INVALID))
- {
- _DBUS_ASSERT_ERROR_IS_SET (error);
- dbus_message_unref (reply);
- return -1;
- }
-
- dbus_message_unref (reply);
-
- return result;
+ return result;
}
* If you pass #NULL for the error, this function will not
* block; the match thus won't be added until you flush the
* connection, and if there's an error adding the match
- * (only possible error is lack of resources in the bus),
- * you won't find out about it.
+ * you won't find out about it. This is generally acceptable, since the
+ * possible errors (including a lack of resources in the bus, the connection
+ * having exceeded its quota of active match rules, or the match rule being
+ * unparseable) are generally unrecoverable.
*
* If you pass non-#NULL for the error this function will
- * block until it gets a reply.
+ * block until it gets a reply. This may be useful when using match rule keys
+ * introduced in recent versions of D-Bus, like 'arg0namespace', to allow the
+ * application to fall back to less efficient match rules supported by older
+ * versions of the daemon if the running version is not new enough; or when
+ * using user-supplied rules rather than rules hard-coded at compile time.
*
* Normal API conventions would have the function return
* a boolean value indicating whether the error was set,
const char *rule,
DBusError *error)
{
- DBusMessage *msg;
+ _dbus_return_if_fail (rule != NULL);
- _dbus_return_if_fail (rule != NULL);
+ if(!dbus_transport_is_kdbus(connection))
+ {
+ DBusMessage *msg;
- msg = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
+ msg = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"AddMatch");
- if (msg == NULL)
- {
- _DBUS_SET_OOM (error);
- return;
- }
-
- if (!dbus_message_append_args (msg, DBUS_TYPE_STRING, &rule,
- DBUS_TYPE_INVALID))
- {
- dbus_message_unref (msg);
- _DBUS_SET_OOM (error);
- return;
- }
-
- send_no_return_values (connection, msg, error);
-
- dbus_message_unref (msg);
+ if (msg == NULL)
+ {
+ _DBUS_SET_OOM (error);
+ return;
+ }
+
+ if (!dbus_message_append_args (msg, DBUS_TYPE_STRING, &rule,
+ DBUS_TYPE_INVALID))
+ {
+ dbus_message_unref (msg);
+ _DBUS_SET_OOM (error);
+ return;
+ }
+
+ send_no_return_values (connection, msg, error);
+
+ dbus_message_unref (msg);
+ }
+ else
+ dbus_bus_add_match_kdbus(connection, rule, error);
}
/**