/* -*- mode: C; c-file-style: "gnu" -*- */
/* driver.c Bus client (driver)
*
- * Copyright (C) 2003 CodeFactory AB
+ * Copyright (C) 2003 CodeFactory AB
+ * Copyright (C) 2003 Red Hat, Inc.
*
* Licensed under the Academic Free License version 1.2
*
*
*/
+#include "activation.h"
#include "connection.h"
#include "driver.h"
#include "dispatch.h"
#include <dbus/dbus-internals.h>
#include <string.h>
-static void bus_driver_send_welcome_message (DBusConnection *connection,
- DBusMessage *hello_message);
+static dbus_bool_t bus_driver_send_welcome_message (DBusConnection *connection,
+ DBusMessage *hello_message,
+ BusTransaction *transaction,
+ DBusError *error);
-void
-bus_driver_send_service_deleted (const char *service_name)
+dbus_bool_t
+bus_driver_send_service_deleted (const char *service_name,
+ BusTransaction *transaction,
+ DBusError *error)
{
DBusMessage *message;
+ dbus_bool_t retval;
- _dbus_verbose ("sending service deleted: %s\n", service_name);
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- BUS_HANDLE_OOM (message = dbus_message_new (DBUS_SERVICE_BROADCAST,
- DBUS_MESSAGE_SERVICE_DELETED));
+ _dbus_verbose ("sending service deleted: %s\n", service_name);
+
+ message = dbus_message_new (DBUS_MESSAGE_SERVICE_DELETED,
+ DBUS_SERVICE_BROADCAST);
+ if (message == NULL)
+ {
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- BUS_HANDLE_OOM (dbus_message_set_sender (message, DBUS_SERVICE_DBUS));
+ if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS) ||
+ !dbus_message_append_args (message,
+ DBUS_TYPE_STRING, service_name,
+ 0))
+ {
+ dbus_message_unref (message);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- BUS_HANDLE_OOM (dbus_message_append_args (message,
- DBUS_TYPE_STRING, service_name,
- 0));
- bus_dispatch_broadcast_message (message);
- dbus_message_unref (message);
+ retval = bus_dispatch_broadcast_message (transaction, NULL, message, error);
+ dbus_message_unref (message);
+
+ return retval;
}
-void
-bus_driver_send_service_created (const char *service_name)
+dbus_bool_t
+bus_driver_send_service_created (const char *service_name,
+ BusTransaction *transaction,
+ DBusError *error)
{
DBusMessage *message;
+ dbus_bool_t retval;
- BUS_HANDLE_OOM (message = dbus_message_new (DBUS_SERVICE_BROADCAST,
- DBUS_MESSAGE_SERVICE_CREATED));
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- BUS_HANDLE_OOM (dbus_message_set_sender (message, DBUS_SERVICE_DBUS));
+ message = dbus_message_new (DBUS_MESSAGE_SERVICE_CREATED,
+ DBUS_SERVICE_BROADCAST);
+ if (message == NULL)
+ {
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+
+ if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS))
+ {
+ dbus_message_unref (message);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- BUS_HANDLE_OOM (dbus_message_append_args (message,
- DBUS_TYPE_STRING, service_name,
- 0));
- bus_dispatch_broadcast_message (message);
+ if (!dbus_message_append_args (message,
+ DBUS_TYPE_STRING, service_name,
+ 0))
+ {
+ dbus_message_unref (message);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+
+ retval = bus_dispatch_broadcast_message (transaction, NULL, message, error);
dbus_message_unref (message);
+
+ return retval;
}
-void
+dbus_bool_t
bus_driver_send_service_lost (DBusConnection *connection,
- const char *service_name)
+ const char *service_name,
+ BusTransaction *transaction,
+ DBusError *error)
{
DBusMessage *message;
- BUS_HANDLE_OOM (message = dbus_message_new (DBUS_SERVICE_BROADCAST,
- DBUS_MESSAGE_SERVICE_LOST));
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- BUS_HANDLE_OOM (dbus_message_set_sender (message, DBUS_SERVICE_DBUS));
- BUS_HANDLE_OOM (dbus_message_append_args (message,
- DBUS_TYPE_STRING, service_name,
- 0));
- BUS_HANDLE_OOM (dbus_connection_send_message (connection, message, NULL, NULL));
+ message = dbus_message_new (DBUS_MESSAGE_SERVICE_LOST,
+ bus_connection_get_name (connection));
+ if (message == NULL)
+ {
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- dbus_message_unref (message);
+ if (!dbus_message_append_args (message,
+ DBUS_TYPE_STRING, service_name,
+ 0))
+ {
+ dbus_message_unref (message);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+
+ if (!bus_transaction_send_from_driver (transaction, connection, message))
+ {
+ dbus_message_unref (message);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+ else
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
}
-void
+dbus_bool_t
bus_driver_send_service_acquired (DBusConnection *connection,
- const char *service_name)
+ const char *service_name,
+ BusTransaction *transaction,
+ DBusError *error)
{
DBusMessage *message;
- BUS_HANDLE_OOM (message = dbus_message_new (DBUS_SERVICE_BROADCAST,
- DBUS_MESSAGE_SERVICE_ACQUIRED));
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- BUS_HANDLE_OOM (dbus_message_set_sender (message, DBUS_SERVICE_DBUS));
- BUS_HANDLE_OOM (dbus_message_append_args (message,
- DBUS_TYPE_STRING, service_name,
- 0));
- BUS_HANDLE_OOM (dbus_connection_send_message (connection, message, NULL, NULL));
+ message = dbus_message_new (DBUS_MESSAGE_SERVICE_ACQUIRED,
+ bus_connection_get_name (connection));
+
+ if (message == NULL)
+ {
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- dbus_message_unref (message);
+ if (!dbus_message_append_args (message,
+ DBUS_TYPE_STRING, service_name,
+ 0))
+ {
+ dbus_message_unref (message);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+
+ if (!bus_transaction_send_from_driver (transaction, connection, message))
+ {
+ dbus_message_unref (message);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+ else
+ {
+ dbus_message_unref (message);
+ return TRUE;
+ }
}
static dbus_bool_t
-create_unique_client_name (DBusString *str)
+create_unique_client_name (BusRegistry *registry,
+ DBusString *str)
{
/* We never want to use the same unique client name twice, because
* we want to guarantee that if you send a message to a given unique
* for INT_MAX * INT_MAX combinations, should be pretty safe against
* wraparound.
*/
+ /* FIXME these should be in BusRegistry rather than static vars */
static int next_major_number = 0;
static int next_minor_number = 0;
int len;
-
+
len = _dbus_string_get_length (str);
while (TRUE)
next_minor_number += 1;
/* Check if a client with the name exists */
- if (bus_service_lookup (str, FALSE) == NULL)
+ if (bus_registry_lookup (registry, str) == NULL)
break;
/* drop the number again, try the next one. */
return TRUE;
}
-static void
+static dbus_bool_t
bus_driver_handle_hello (DBusConnection *connection,
- DBusMessage *message)
+ BusTransaction *transaction,
+ DBusMessage *message,
+ DBusError *error)
{
DBusString unique_name;
BusService *service;
+ dbus_bool_t retval;
+ BusRegistry *registry;
+ BusConnections *connections;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ /* Note that when these limits are exceeded we don't disconnect the
+ * connection; we just sort of leave it hanging there until it times
+ * out or disconnects itself or is dropped due to the max number of
+ * incomplete connections. It's even OK if the connection wants to
+ * retry the hello message, we support that.
+ */
+ connections = bus_connection_get_connections (connection);
+ if (!bus_connections_check_limits (connections, connection,
+ error))
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return FALSE;
+ }
- BUS_HANDLE_OOM (_dbus_string_init (&unique_name, _DBUS_INT_MAX));
- BUS_HANDLE_OOM (create_unique_client_name (&unique_name));
+ if (!_dbus_string_init (&unique_name))
+ {
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- BUS_HANDLE_OOM (bus_connection_set_name (connection, &unique_name));
- BUS_HANDLE_OOM (dbus_message_set_sender (message,
- bus_connection_get_name (connection)));
+ retval = FALSE;
+
+ registry = bus_connection_get_registry (connection);
- BUS_HANDLE_OOM (bus_driver_send_welcome_message (connection, message));
+ if (!create_unique_client_name (registry, &unique_name))
+ {
+ BUS_SET_OOM (error);
+ goto out_0;
+ }
+
+ if (!bus_connection_complete (connection, &unique_name, error))
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ goto out_0;
+ }
+
+ if (!dbus_message_set_sender (message,
+ bus_connection_get_name (connection)))
+ {
+ BUS_SET_OOM (error);
+ goto out_0;
+ }
+
+ if (!bus_driver_send_welcome_message (connection, message, transaction, error))
+ goto out_0;
/* Create the service */
- BUS_HANDLE_OOM (service = bus_service_lookup (&unique_name, TRUE));
- bus_service_set_prohibit_replacement (service, TRUE);
+ service = bus_registry_ensure (registry,
+ &unique_name, connection, transaction, error);
+ if (service == NULL)
+ goto out_0;
- /* Add the connection as the owner */
- BUS_HANDLE_OOM (bus_service_add_owner (service, connection));
+ bus_service_set_prohibit_replacement (service, TRUE);
+ retval = TRUE;
+
+ out_0:
_dbus_string_free (&unique_name);
+ return retval;
}
-static void
+static dbus_bool_t
bus_driver_send_welcome_message (DBusConnection *connection,
- DBusMessage *hello_message)
+ DBusMessage *hello_message,
+ BusTransaction *transaction,
+ DBusError *error)
{
DBusMessage *welcome;
const char *name;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
name = bus_connection_get_name (connection);
_dbus_assert (name != NULL);
- BUS_HANDLE_OOM (welcome = dbus_message_new_reply (hello_message));
-
- BUS_HANDLE_OOM (dbus_message_set_sender (welcome, DBUS_SERVICE_DBUS));
-
- BUS_HANDLE_OOM (dbus_message_append_args (welcome,
- DBUS_TYPE_STRING, name,
- NULL));
+ welcome = dbus_message_new_reply (hello_message);
+ if (welcome == NULL)
+ {
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- BUS_HANDLE_OOM (dbus_connection_send_message (connection, welcome, NULL, NULL));
+ if (!dbus_message_append_args (welcome,
+ DBUS_TYPE_STRING, name,
+ NULL))
+ {
+ dbus_message_unref (welcome);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- dbus_message_unref (welcome);
+ if (!bus_transaction_send_from_driver (transaction, connection, welcome))
+ {
+ dbus_message_unref (welcome);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+ else
+ {
+ dbus_message_unref (welcome);
+ return TRUE;
+ }
}
-static void
+static dbus_bool_t
bus_driver_handle_list_services (DBusConnection *connection,
- DBusMessage *message)
+ BusTransaction *transaction,
+ DBusMessage *message,
+ DBusError *error)
{
DBusMessage *reply;
- int len, i;
+ int len;
char **services;
+ BusRegistry *registry;
- BUS_HANDLE_OOM (reply = dbus_message_new_reply (message));
-
- BUS_HANDLE_OOM (services = bus_services_list (&len));
-
- BUS_HANDLE_OOM (dbus_message_append_args (reply,
- DBUS_TYPE_STRING_ARRAY, services, len,
- 0));
-
- BUS_HANDLE_OOM (dbus_connection_send_message (connection, reply, NULL, NULL));
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ registry = bus_connection_get_registry (connection);
+
+ reply = dbus_message_new_reply (message);
+ if (reply == NULL)
+ {
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- dbus_message_unref (reply);
+ if (!bus_registry_list_services (registry, &services, &len))
+ {
+ dbus_message_unref (reply);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+
+ if (!dbus_message_append_args (reply,
+ DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, services, len,
+ 0))
+ {
+ dbus_free_string_array (services);
+ dbus_message_unref (reply);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
- if (services != NULL)
+ dbus_free_string_array (services);
+
+ if (!bus_transaction_send_from_driver (transaction, connection, reply))
+ {
+ dbus_message_unref (reply);
+ BUS_SET_OOM (error);
+ return FALSE;
+ }
+ else
{
- for (i = 0; i < len; i++)
- dbus_free (services[i]);
- dbus_free (services);
+ dbus_message_unref (reply);
+ return TRUE;
}
}
-static void
+static dbus_bool_t
bus_driver_handle_acquire_service (DBusConnection *connection,
- DBusMessage *message)
+ BusTransaction *transaction,
+ DBusMessage *message,
+ DBusError *error)
{
DBusMessage *reply;
- DBusResultCode result;
DBusString service_name;
- BusService *service;
char *name;
int service_reply;
int flags;
+ dbus_bool_t retval;
+ BusRegistry *registry;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- BUS_HANDLE_OOM ((result = dbus_message_get_args (message,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_UINT32, &flags,
- 0)) != DBUS_RESULT_NO_MEMORY);
+ registry = bus_connection_get_registry (connection);
- if (result != DBUS_RESULT_SUCCESS)
- {
- dbus_free (name);
- dbus_connection_disconnect (connection);
- return;
- }
-
- _dbus_verbose ("Trying to own service %s with flags %d\n", name, flags);
+ if (!dbus_message_get_args (message, error,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_UINT32, &flags,
+ 0))
+ return FALSE;
+
+ _dbus_verbose ("Trying to own service %s with flags 0x%x\n", name, flags);
+
+ retval = FALSE;
+ reply = NULL;
_dbus_string_init_const (&service_name, name);
- service = bus_service_lookup (&service_name, TRUE);
- BUS_HANDLE_OOM ((reply = dbus_message_new_reply (message)));
+ if (!bus_registry_acquire_service (registry, connection,
+ &service_name, flags,
+ &service_reply, transaction,
+ error))
+ goto out;
- /*
- * Check if the service already has an owner
- */
- if (bus_service_get_primary_owner (service) != NULL)
- {
- if (bus_service_has_owner (service, connection))
- service_reply = DBUS_SERVICE_REPLY_ALREADY_OWNER;
- else if (!(flags & DBUS_SERVICE_FLAG_REPLACE_EXISTING))
- service_reply = DBUS_SERVICE_REPLY_SERVICE_EXISTS;
- else
- {
- if (bus_service_get_prohibit_replacement (service))
- {
-
- /* Queue the connection */
- BUS_HANDLE_OOM (bus_service_add_owner (service, connection));
-
- service_reply = DBUS_SERVICE_REPLY_IN_QUEUE;
- }
- else
- {
- DBusConnection *owner;
-
- /* We can replace the primary owner */
- owner = bus_service_get_primary_owner (service);
-
- /* We enqueue the new owner and remove the first one because
- * that will cause ServiceAcquired and ServiceLost messages to
- * be sent.
- */
- BUS_HANDLE_OOM (bus_service_add_owner (service, connection));
- bus_service_remove_owner (service, owner);
- _dbus_assert (connection == bus_service_get_primary_owner (service));
- service_reply = DBUS_SERVICE_REPLY_PRIMARY_OWNER;
- }
- }
+ reply = dbus_message_new_reply (message);
+ if (reply == NULL)
+ {
+ BUS_SET_OOM (error);
+ goto out;
}
- else
+
+ if (!dbus_message_append_args (reply, DBUS_TYPE_UINT32, service_reply, DBUS_TYPE_INVALID))
{
- bus_service_set_prohibit_replacement (service,
- (flags & DBUS_SERVICE_FLAG_PROHIBIT_REPLACEMENT));
-
- /* Broadcast service created message */
- bus_driver_send_service_created (bus_service_get_name (service));
-
- BUS_HANDLE_OOM (bus_service_add_owner (service, connection));
-
- service_reply = DBUS_SERVICE_REPLY_PRIMARY_OWNER;
+ BUS_SET_OOM (error);
+ goto out;
}
- BUS_HANDLE_OOM (dbus_message_append_args (reply, DBUS_TYPE_UINT32, service_reply, 0));
+ if (!bus_transaction_send_from_driver (transaction, connection, reply))
+ {
+ BUS_SET_OOM (error);
+ goto out;
+ }
- /* Send service reply */
- BUS_HANDLE_OOM (dbus_connection_send_message (connection, reply, NULL, NULL));
+ retval = TRUE;
+
+ out:
dbus_free (name);
- dbus_message_unref (reply);
-}
+ if (reply)
+ dbus_message_unref (reply);
+ return retval;
+}
-static void
+static dbus_bool_t
bus_driver_handle_service_exists (DBusConnection *connection,
- DBusMessage *message)
+ BusTransaction *transaction,
+ DBusMessage *message,
+ DBusError *error)
{
DBusMessage *reply;
- DBusResultCode result;
DBusString service_name;
BusService *service;
char *name;
+ dbus_bool_t retval;
+ BusRegistry *registry;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- BUS_HANDLE_OOM ((result = dbus_message_get_args (message,
- DBUS_TYPE_STRING, &name,
- 0)) != DBUS_RESULT_NO_MEMORY);
- if (result != DBUS_RESULT_SUCCESS)
- {
- dbus_free (name);
- dbus_connection_disconnect (connection);
- return;
- }
+ registry = bus_connection_get_registry (connection);
+
+ if (!dbus_message_get_args (message, error,
+ DBUS_TYPE_STRING, &name,
+ 0))
+ return FALSE;
+ retval = FALSE;
+
_dbus_string_init_const (&service_name, name);
- service = bus_service_lookup (&service_name, FALSE);
+ service = bus_registry_lookup (registry, &service_name);
- BUS_HANDLE_OOM ((reply = dbus_message_new_reply (message)));
- BUS_HANDLE_OOM (dbus_message_set_sender (reply, DBUS_SERVICE_DBUS));
-
- BUS_HANDLE_OOM (dbus_message_append_args (reply,
- DBUS_TYPE_UINT32, service != NULL,
- 0));
- BUS_HANDLE_OOM (dbus_connection_send_message (connection, reply, NULL, NULL));
- dbus_message_unref (reply);
+ reply = dbus_message_new_reply (message);
+ if (reply == NULL)
+ {
+ BUS_SET_OOM (error);
+ goto out;
+ }
+
+ if (!dbus_message_append_args (reply,
+ DBUS_TYPE_UINT32, service != NULL,
+ 0))
+ {
+ BUS_SET_OOM (error);
+ goto out;
+ }
+
+ if (!bus_transaction_send_from_driver (transaction, connection, reply))
+ {
+ BUS_SET_OOM (error);
+ goto out;
+ }
+
+ retval = TRUE;
+
+ out:
+ if (reply)
+ dbus_message_unref (reply);
dbus_free (name);
+
+ return retval;
}
-void
+static dbus_bool_t
+bus_driver_handle_activate_service (DBusConnection *connection,
+ BusTransaction *transaction,
+ DBusMessage *message,
+ DBusError *error)
+{
+ dbus_uint32_t flags;
+ char *name;
+ dbus_bool_t retval;
+ BusActivation *activation;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ activation = bus_connection_get_activation (connection);
+
+ if (!dbus_message_get_args (message, error,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_UINT32, &flags,
+ 0))
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ _dbus_verbose ("No memory to get arguments to ActivateService\n");
+ return FALSE;
+ }
+
+ retval = FALSE;
+
+ if (!bus_activation_activate_service (activation, connection, transaction,
+ message, name, error))
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ _dbus_verbose ("bus_activation_activate_service() failed\n");
+ goto out;
+ }
+
+ retval = TRUE;
+
+ out:
+ dbus_free (name);
+ return retval;
+}
+
+/* For speed it might be useful to sort this in order of
+ * frequency of use (but doesn't matter with only a few items
+ * anyhow)
+ */
+struct
+{
+ const char *name;
+ dbus_bool_t (* handler) (DBusConnection *connection,
+ BusTransaction *transaction,
+ DBusMessage *message,
+ DBusError *error);
+} message_handlers[] = {
+ { DBUS_MESSAGE_ACQUIRE_SERVICE, bus_driver_handle_acquire_service },
+ { DBUS_MESSAGE_ACTIVATE_SERVICE, bus_driver_handle_activate_service },
+ { DBUS_MESSAGE_HELLO, bus_driver_handle_hello },
+ { DBUS_MESSAGE_SERVICE_EXISTS, bus_driver_handle_service_exists },
+ { DBUS_MESSAGE_LIST_SERVICES, bus_driver_handle_list_services }
+};
+
+dbus_bool_t
bus_driver_handle_message (DBusConnection *connection,
- DBusMessage *message)
+ BusTransaction *transaction,
+ DBusMessage *message,
+ DBusError *error)
{
const char *name, *sender;
+ int i;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
_dbus_verbose ("Driver got a message: %s\n",
dbus_message_get_name (message));
name = dbus_message_get_name (message);
sender = dbus_message_get_sender (message);
- if (sender == NULL && (strcmp (name, DBUS_MESSAGE_HELLO) != 0))
+ /* security checks should have kept this from getting here */
+ _dbus_assert (sender != NULL || strcmp (name, DBUS_MESSAGE_HELLO) == 0);
+
+ if (dbus_message_get_reply_serial (message) == 0)
+ {
+ _dbus_verbose ("Client sent a reply to the bus driver, ignoring it\n");
+ return TRUE;
+ }
+
+ i = 0;
+ while (i < _DBUS_N_ELEMENTS (message_handlers))
{
- _dbus_verbose ("Trying to send a message without being registered. Disconnecting.\n");
- dbus_connection_disconnect (connection);
- return;
+ if (strcmp (message_handlers[i].name, name) == 0)
+ {
+ _dbus_verbose ("Running driver handler for %s\n", name);
+ if ((* message_handlers[i].handler) (connection, transaction, message, error))
+ {
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ _dbus_verbose ("Driver handler succeeded\n");
+ return TRUE;
+ }
+ else
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ _dbus_verbose ("Driver handler returned failure\n");
+ return FALSE;
+ }
+ }
+
+ ++i;
}
- /* Now check names. */
- if (strcmp (name, DBUS_MESSAGE_HELLO) == 0)
- bus_driver_handle_hello (connection, message);
- else if (strcmp (name, DBUS_MESSAGE_LIST_SERVICES) == 0)
- bus_driver_handle_list_services (connection, message);
- else if (strcmp (name, DBUS_MESSAGE_ACQUIRE_SERVICE) == 0)
- bus_driver_handle_acquire_service (connection, message);
- else if (strcmp (name, DBUS_MESSAGE_SERVICE_EXISTS) == 0)
- bus_driver_handle_service_exists (connection, message);
+ _dbus_verbose ("No driver handler for %s\n", name);
+
+ dbus_set_error (error, DBUS_ERROR_UNKNOWN_MESSAGE,
+ "%s does not understand message %s",
+ DBUS_SERVICE_DBUS, name);
+ return FALSE;
}
void
bus_driver_remove_connection (DBusConnection *connection)
{
- /* Does nothing for now */
+ /* FIXME Does nothing for now, should unregister the connection
+ * with the bus driver.
+ */
}
projects / platform / upstream / dbus.git / blobdiff