+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
if (dbus_connection_get_is_connected (entry->connection))
{
- message = dbus_message_new_reply (entry->activation_message);
+ message = dbus_message_new_method_return (entry->activation_message);
if (!message)
{
BUS_SET_OOM (error);
{
_dbus_verbose ("Service \"%s\" is already active\n", service_name);
- message = dbus_message_new_reply (activation_message);
+ message = dbus_message_new_method_return (activation_message);
if (!message)
{
if (preallocated == NULL)
return FALSE;
- /* d->name may be NULL, but that is OK */
- message = dbus_message_new (DBUS_ERROR_NO_MEMORY,
- d->name);
+ message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
+
if (message == NULL)
{
dbus_connection_free_preallocated_send (connection, preallocated);
return FALSE;
}
- dbus_message_set_is_error (message, TRUE);
-
- if (!dbus_message_set_sender (message,
+ /* d->name may be NULL, but that is OK */
+ if (!dbus_message_set_name (message, DBUS_ERROR_NO_MEMORY) ||
+ !dbus_message_set_destination (message, d->name) ||
+ !dbus_message_set_sender (message,
DBUS_SERVICE_DBUS))
{
dbus_connection_free_preallocated_send (connection, preallocated);
DBusList *link;
_dbus_verbose (" trying to add %s %s to transaction%s\n",
- dbus_message_get_is_error (message) ? "error" :
+ dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR ? "error" :
dbus_message_get_reply_serial (message) != 0 ? "reply" :
"message",
dbus_message_get_name (message),
_dbus_verbose ("Sending error reply %s \"%s\"\n",
error->name, error->message);
- reply = dbus_message_new_error_reply (in_reply_to,
- error->name,
- error->message);
+ reply = dbus_message_new_error (in_reply_to,
+ error->name,
+ error->message);
if (reply == NULL)
return FALSE;
acquired = NULL;
message = NULL;
- message = dbus_message_new (DBUS_MESSAGE_HELLO,
- DBUS_SERVICE_DBUS);
+ message = dbus_message_new_method_call (DBUS_MESSAGE_HELLO,
+ DBUS_SERVICE_DBUS);
if (message == NULL)
return TRUE;
goto out;
}
- if (dbus_message_get_is_error (message))
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
if (dbus_message_has_name (message,
DBUS_ERROR_NO_MEMORY))
dbus_error_init (&error);
- message = dbus_message_new (DBUS_MESSAGE_ACTIVATE_SERVICE,
- DBUS_SERVICE_DBUS);
+ message = dbus_message_new_method_call (DBUS_MESSAGE_ACTIVATE_SERVICE,
+ DBUS_SERVICE_DBUS);
if (message == NULL)
return TRUE;
_dbus_verbose ("Received %s on %p\n",
dbus_message_get_name (message), connection);
- if (dbus_message_get_is_error (message))
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
retval = FALSE;
/* Kill off the test service by sending it a quit message */
- message = dbus_message_new ("org.freedesktop.DBus.TestSuiteExit",
- service_name);
+ message = dbus_message_new_method_call ("org.freedesktop.DBus.TestSuiteExit",
+ service_name);
if (message == NULL)
{
/* see if we got an error during message bus dispatching */
bus_test_run_clients_loop (FALSE);
message = dbus_connection_borrow_message (connection);
- got_error = message != NULL && dbus_message_get_is_error (message);
+ got_error = message != NULL && dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR;
if (message)
{
dbus_connection_return_message (connection, message);
message = pop_message_waiting_for_memory (connection);
_dbus_assert (message != NULL);
- if (!dbus_message_get_is_error (message))
+ if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
{
_dbus_warn ("expecting an error reply to asking test service to exit, got %s\n",
dbus_message_get_name (message));
goto out;
}
- if (!dbus_message_get_is_error (message))
+ if (dbus_message_get_type (message) != DBUS_MESSAGE_TYPE_ERROR)
{
_dbus_warn ("Expected an error, got %s\n",
dbus_message_get_name (message));
dbus_error_init (&error);
- message = dbus_message_new (DBUS_MESSAGE_ACTIVATE_SERVICE,
- DBUS_SERVICE_DBUS);
+ message = dbus_message_new_method_call (DBUS_MESSAGE_ACTIVATE_SERVICE,
+ DBUS_SERVICE_DBUS);
if (message == NULL)
return TRUE;
dbus_message_get_name (message), connection,
DBUS_MESSAGE_ACTIVATE_SERVICE);
- if (dbus_message_get_is_error (message))
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
}
got_service_deleted = dbus_message_has_name (message, DBUS_MESSAGE_SERVICE_DELETED);
- got_error = dbus_message_get_is_error (message);
+ got_error = dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR;
dbus_connection_return_message (connection, message);
message = NULL;
dbus_error_init (&error);
- message = dbus_message_new (DBUS_MESSAGE_ACTIVATE_SERVICE,
- DBUS_SERVICE_DBUS);
+ message = dbus_message_new_method_call (DBUS_MESSAGE_ACTIVATE_SERVICE,
+ DBUS_SERVICE_DBUS);
if (message == NULL)
return TRUE;
_dbus_verbose ("Received %s on %p\n",
dbus_message_get_name (message), connection);
- if (dbus_message_get_is_error (message))
+ if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR)
{
if (!dbus_message_has_sender (message, DBUS_SERVICE_DBUS))
{
_dbus_verbose ("sending service deleted: %s\n", service_name);
- message = dbus_message_new (DBUS_MESSAGE_SERVICE_DELETED,
- DBUS_SERVICE_BROADCAST);
+ message = dbus_message_new_signal (DBUS_MESSAGE_SERVICE_DELETED);
+
if (message == NULL)
{
BUS_SET_OOM (error);
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- message = dbus_message_new (DBUS_MESSAGE_SERVICE_CREATED,
- DBUS_SERVICE_BROADCAST);
+ message = dbus_message_new_signal (DBUS_MESSAGE_SERVICE_CREATED);
+
if (message == NULL)
{
BUS_SET_OOM (error);
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- message = dbus_message_new (DBUS_MESSAGE_SERVICE_LOST,
- bus_connection_get_name (connection));
+ message = dbus_message_new_signal (DBUS_MESSAGE_SERVICE_LOST);
+
if (message == NULL)
{
BUS_SET_OOM (error);
return FALSE;
}
- if (!dbus_message_append_args (message,
+ if (!dbus_message_set_destination (message, bus_connection_get_name (connection)) ||
+ !dbus_message_append_args (message,
DBUS_TYPE_STRING, service_name,
DBUS_TYPE_INVALID))
{
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
- message = dbus_message_new (DBUS_MESSAGE_SERVICE_ACQUIRED,
- bus_connection_get_name (connection));
+ message = dbus_message_new_signal (DBUS_MESSAGE_SERVICE_ACQUIRED);
if (message == NULL)
{
return FALSE;
}
- if (!dbus_message_append_args (message,
+ if (!dbus_message_set_destination (message, bus_connection_get_name (connection)) ||
+ !dbus_message_append_args (message,
DBUS_TYPE_STRING, service_name,
DBUS_TYPE_INVALID))
{
name = bus_connection_get_name (connection);
_dbus_assert (name != NULL);
- welcome = dbus_message_new_reply (hello_message);
+ welcome = dbus_message_new_method_return (hello_message);
if (welcome == NULL)
{
BUS_SET_OOM (error);
registry = bus_connection_get_registry (connection);
- reply = dbus_message_new_reply (message);
+ reply = dbus_message_new_method_return (message);
if (reply == NULL)
{
BUS_SET_OOM (error);
error))
goto out;
- reply = dbus_message_new_reply (message);
+ reply = dbus_message_new_method_return (message);
if (reply == NULL)
{
BUS_SET_OOM (error);
_dbus_string_init_const (&service_name, name);
service = bus_registry_lookup (registry, &service_name);
- reply = dbus_message_new_reply (message);
+ reply = dbus_message_new_method_return (message);
if (reply == NULL)
{
BUS_SET_OOM (error);
DBusMessage *message,
void *user_data)
{
+ if (!dbus_message_has_name (message,
+ DBUS_MESSAGE_LOCAL_DISCONNECT))
+ return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+
_dbus_verbose ("Removing client %p in disconnect handler\n",
connection);
bus_setup_debug_client (DBusConnection *connection)
{
DBusMessageHandler *disconnect_handler;
- const char *to_handle[] = { DBUS_MESSAGE_LOCAL_DISCONNECT };
dbus_bool_t retval;
disconnect_handler = dbus_message_handler_new (client_disconnect_handler,
if (disconnect_handler == NULL)
return FALSE;
- if (!dbus_connection_register_handler (connection,
- disconnect_handler,
- to_handle,
- _DBUS_N_ELEMENTS (to_handle)))
+ if (!dbus_connection_add_filter (connection,
+ disconnect_handler))
{
dbus_message_handler_unref (disconnect_handler);
return FALSE;
cflags: ${CFLAGS}
cppflags: ${CPPFLAGS}
cxxflags: ${CXXFLAGS}
+ 64-bit int: ${DBUS_INT64_TYPE}
Doxygen: ${DOXYGEN}
db2html: ${DB2HTML}"
connection->outgoing_counter = outgoing_counter;
connection->filter_list = NULL;
connection->last_dispatch_status = DBUS_DISPATCH_COMPLETE; /* so we're notified first time there's data */
+ connection->objects = objects;
_dbus_data_slot_list_init (&connection->slot_list);
return append_string_field (message, field,
DBUS_HEADER_FIELD_SENDER,
value);
+ case FIELD_NAME:
+ return append_string_field (message, field,
+ DBUS_HEADER_FIELD_NAME,
+ value);
+ case FIELD_SERVICE:
+ return append_string_field (message, field,
+ DBUS_HEADER_FIELD_SERVICE,
+ value);
default:
_dbus_assert_not_reached ("appending a string field we don't support appending");
return FALSE;
return FALSE;
}
- _dbus_assert (name != NULL);
- if (!append_string_field (message,
- FIELD_NAME,
- DBUS_HEADER_FIELD_NAME,
- name))
- return FALSE;
+ if (name != NULL)
+ {
+ if (!append_string_field (message,
+ FIELD_NAME,
+ DBUS_HEADER_FIELD_NAME,
+ name))
+ return FALSE;
+ }
return TRUE;
}
return message;
}
+/**
+ * Constructs a new message of the given message type.
+ * Types include #DBUS_MESSAGE_TYPE_METHOD_CALL,
+ * #DBUS_MESSAGE_TYPE_SIGNAL, and so forth.
+ *
+ * @param message_type type of message
+ * @returns new message or #NULL If no memory
+ */
+DBusMessage*
+dbus_message_new (int message_type)
+{
+ DBusMessage *message;
+
+ _dbus_return_val_if_fail (message_type != DBUS_MESSAGE_TYPE_INVALID, NULL);
+
+ message = dbus_message_new_empty_header ();
+ if (message == NULL)
+ return NULL;
+
+ if (!dbus_message_create_header (message,
+ message_type,
+ NULL, NULL))
+ {
+ dbus_message_unref (message);
+ return NULL;
+ }
+
+ return message;
+}
/**
* Constructs a new message to invoke a method on a remote
return type;
}
+
+/**
+ * Sets the message name.
+ *
+ * @param message the message
+ * @param name the name
+ * @returns #FALSE if not enough memory
+ */
+dbus_bool_t
+dbus_message_set_name (DBusMessage *message,
+ const char *name)
+{
+ _dbus_return_val_if_fail (message != NULL, FALSE);
+ _dbus_return_val_if_fail (!message->locked, FALSE);
+
+ if (name == NULL)
+ {
+ delete_string_field (message, FIELD_NAME);
+ return TRUE;
+ }
+ else
+ {
+ return set_string_field (message,
+ FIELD_NAME,
+ name);
+ }
+}
+
/**
* Gets the name of a message.
*
return get_string_field (message, FIELD_NAME, NULL);
}
+/**
+ * Sets the message's destination service.
+ *
+ * @param message the message
+ * @param destination the destination service name
+ * @returns #FALSE if not enough memory
+ */
+dbus_bool_t
+dbus_message_set_destination (DBusMessage *message,
+ const char *destination)
+{
+ _dbus_return_val_if_fail (message != NULL, FALSE);
+ _dbus_return_val_if_fail (!message->locked, FALSE);
+
+ if (destination == NULL)
+ {
+ delete_string_field (message, FIELD_SERVICE);
+ return TRUE;
+ }
+ else
+ {
+ return set_string_field (message,
+ FIELD_SERVICE,
+ destination);
+ }
+}
+
/**
* Gets the destination service of a message.
*
void *pad3;
};
+DBusMessage* dbus_message_new (int message_type);
DBusMessage* dbus_message_new_method_call (const char *name,
const char *destination_service);
DBusMessage* dbus_message_new_method_return (DBusMessage *method_call);
void dbus_message_ref (DBusMessage *message);
void dbus_message_unref (DBusMessage *message);
int dbus_message_get_type (DBusMessage *message);
+dbus_bool_t dbus_message_set_name (DBusMessage *message,
+ const char *name);
const char* dbus_message_get_name (DBusMessage *message);
+dbus_bool_t dbus_message_set_destination (DBusMessage *message,
+ const char *destination);
const char* dbus_message_get_destination (DBusMessage *message);
dbus_bool_t dbus_message_set_sender (DBusMessage *message,
const char *sender);
object_entry = validate_id (registry, &objects[i].id);
if (object_entry != NULL)
{
- DBusObjectVTable *vtable;
+ const DBusObjectVTable *vtable;
DBusObjectInfo info;
info_from_entry (registry, &info, object_entry);
<entry>1</entry>
<entry>Method call.</entry>
</row>
- </row>
<row>
<entry>2</entry>
<entry>Method reply with returned data.</entry>
dbus_connection_setup_with_g_main (connection, NULL);
- message = dbus_message_new (DBUS_MESSAGE_HELLO,
- DBUS_SERVICE_DBUS);
+ message = dbus_message_new_method_call (DBUS_MESSAGE_HELLO,
+ DBUS_SERVICE_DBUS);
dbus_error_init (&error);
reply = dbus_connection_send_with_reply_and_block (connection, message, -1, &error);
{
DBusMessage *message;
- message = dbus_message_new (ECHO_MESSAGE, NULL);
+ message = dbus_message_new_method_call (ECHO_MESSAGE, NULL);
dbus_message_append_args (message,
DBUS_TYPE_STRING, "Hello World!",
DBUS_TYPE_INT32, 123456,
while (1)
{
- message = dbus_message_new ("org.freedesktop.ThreadTest", NULL);
+ message = dbus_message_new_method_call ("org.freedesktop.ThreadTest", NULL);
dbus_message_append_iter_init (message, &iter);
char *str, *expected_str;
GString *counter_str;
int i;
+
+ if (!dbus_message_has_name (message, "org.freedesktop.ThreadTest"))
+ return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
dbus_message_iter_init (message, &iter);
g_string_free (counter_str, TRUE);
out:
- return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+ return DBUS_HANDLER_RESULT_REMOVE_MESSAGE;
}
static DBusHandlerResult
DBusConnection *connection,
DBusMessage *message,
void *user_data)
-{
+{
return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
DBusMessage *message,
void *user_data)
{
+ if (!dbus_message_has_name (message, DBUS_MESSAGE_LOCAL_DISCONNECT))
+ return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+
g_print ("connection disconnected\n");
dbus_connection_unref (connection);
-
- return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+
+ return DBUS_HANDLER_RESULT_REMOVE_MESSAGE;
}
-
static void
new_connection_callback (DBusServer *server,
DBusConnection *new_connection,
void *user_data)
{
- const char *test_messages[] = { "org.freedesktop.ThreadTest" };
- const char *disconnect_messages[] = { "org.freedesktop.Local.Disconnect" };
DBusMessageHandler *test_message_handler;
ThreadTestData * data;
dbus_message_handler_new (handle_test_message,
data, (DBusFreeFunction)thread_test_data_free);
- if (!dbus_connection_register_handler (new_connection,
- test_message_handler,
- test_messages, 1))
+ if (!dbus_connection_add_filter (new_connection,
+ test_message_handler))
goto nomem;
if (!dbus_connection_set_data (new_connection,
(DBusFreeFunction)dbus_message_handler_unref))
goto nomem;
- if (!dbus_connection_register_handler (new_connection,
- disconnect_handler,
- disconnect_messages, 1))
+ if (!dbus_connection_add_filter (new_connection,
+ disconnect_handler))
goto nomem;
if (!dbus_connection_add_filter (new_connection,
#include <stdlib.h>
#include <string.h>
+#ifndef DBUS_HAVE_INT64
+#error "gcov support can't be built without 64-bit integer support"
+#endif
+
static void
die (const char *message)
{
DBUS_TYPE_STRING, &s,
DBUS_TYPE_INVALID))
{
- reply = dbus_message_new_error_reply (message,
- error.name,
- error.message);
+ reply = dbus_message_new_error (message,
+ error.name,
+ error.message);
if (reply == NULL)
die ("No memory\n");
return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
}
- reply = dbus_message_new_reply (message);
+ reply = dbus_message_new_method_return (message);
if (reply == NULL)
die ("No memory\n");
DBusConnection *connection;
DBusError error;
DBusMessageHandler *handler;
- const char *to_handle[] = {
- "org.freedesktop.DBus.TestSuiteEcho",
- "org.freedesktop.DBus.TestSuiteExit",
- DBUS_MESSAGE_LOCAL_DISCONNECT,
- };
int result;
dbus_error_init (&error);
if (handler == NULL)
die ("No memory");
- if (!dbus_connection_register_handler (connection, handler, to_handle,
- _DBUS_N_ELEMENTS (to_handle)))
+ if (!dbus_connection_add_filter (connection, handler))
die ("No memory");
result = dbus_bus_acquire_service (connection, "org.freedesktop.DBus.TestSuiteEchoService",
*/
#include "dbus-print-message.h"
+static const char*
+type_to_name (int message_type)
+{
+ switch (message_type)
+ {
+ case DBUS_MESSAGE_TYPE_SIGNAL:
+ return "signal";
+ case DBUS_MESSAGE_TYPE_METHOD_CALL:
+ return "method call";
+ case DBUS_MESSAGE_TYPE_METHOD_RETURN:
+ return "method return";
+ case DBUS_MESSAGE_TYPE_ERROR:
+ return "error";
+ default:
+ return "(unknown message type)";
+ }
+}
+
void
print_message (DBusMessage *message)
{
DBusMessageIter iter;
const char *sender;
+ int message_type;
+ message_type = dbus_message_get_type (message);
sender = dbus_message_get_sender (message);
- printf ("message name=%s; sender=%s\n",
+ printf ("%s name=%s; sender=%s\n",
+ type_to_name (message_type),
dbus_message_get_name (message),
sender ? sender : "(no sender)");
.SH SYNOPSIS
.PP
.B dbus-send
-[\-\-system | \-\-session] [\-\-dest=SERVICE] [\-\-print-reply] <message name> [contents ...]
+[\-\-system | \-\-session] [\-\-dest=SERVICE] [\-\-print-reply] [\-\-type=TYPE] <message name> [contents ...]
.SH DESCRIPTION
.TP
.I "--session"
Send to the session message bus. (This is the default.)
+.TP
+.I "--type=TYPE"
+Specify "method_call" or "signal" (defaults to "signal").
.SH AUTHOR
dbus-send was written by Philip Blundell.
static void
usage (char *name, int ecode)
{
- fprintf (stderr, "Usage: %s [--help] [--system | --session] [--dest=SERVICE] [--print-reply] <message type> [contents ...]\n", name);
+ fprintf (stderr, "Usage: %s [--help] [--system | --session] [--dest=SERVICE] [--type=TYPE] [--print-reply] <message name> [contents ...]\n", name);
exit (ecode);
}
DBusMessageIter iter;
int i;
DBusBusType type = DBUS_BUS_SESSION;
- char *dest = DBUS_SERVICE_BROADCAST;
+ const char *dest = DBUS_SERVICE_BROADCAST;
char *name = NULL;
-
+ int message_type = DBUS_MESSAGE_TYPE_SIGNAL;
+ const char *type_str = NULL;
+
if (argc < 2)
usage (argv[0], 1);
print_reply = TRUE;
else if (strstr (arg, "--dest=") == arg)
dest = strchr (arg, '=') + 1;
+ else if (strstr (arg, "--type=") == arg)
+ type_str = strchr (arg, '=') + 1;
else if (!strcmp(arg, "--help"))
usage (argv[0], 0);
else if (arg[0] == '-')
if (name == NULL)
usage (argv[0], 1);
+ if (type_str != NULL)
+ {
+ if (strcmp (type_str, "method_call") == 0)
+ message_type = DBUS_MESSAGE_TYPE_METHOD_CALL;
+ else if (strcmp (type_str, "signal") == 0)
+ message_type = DBUS_MESSAGE_TYPE_SIGNAL;
+ else
+ {
+ fprintf (stderr, "Message type \"%s\" is not supported\n",
+ type_str);
+ exit (1);
+ }
+ }
+
dbus_error_init (&error);
connection = dbus_bus_get (type, &error);
if (connection == NULL)
exit (1);
}
- message = dbus_message_new (name, dest);
+ if (message_type == DBUS_MESSAGE_TYPE_METHOD_CALL)
+ {
+ message = dbus_message_new_method_call (name, NULL);
+ }
+ else if (message_type == DBUS_MESSAGE_TYPE_SIGNAL)
+ {
+ message = dbus_message_new_signal (name);
+ }
+ else
+ {
+ fprintf (stderr, "Internal error, unknown message type\n");
+ exit (1);
+ }
+
if (message == NULL)
{
fprintf (stderr, "Couldn't allocate D-BUS message\n");
exit (1);
}
+ if (dest && !dbus_message_set_destination (message, dest))
+ {
+ fprintf (stderr, "Not enough memory\n");
+ exit (1);
+ }
+
dbus_message_append_iter_init (message, &iter);
while (i < argc)
exit (1);
}
+ /* FIXME - we are ignoring OOM returns on all these functions */
switch (type)
{
case DBUS_TYPE_BYTE:
projects / platform / upstream / dbus.git / commitdiff