+2003-10-16 Havoc Pennington <hp@redhat.com>
+
+ * bus/connection.c (bus_pending_reply_expired): either cancel or
+ execute, not both
+ (bus_connections_check_reply): use unlink, not remove_link, as we
+ don't want to free the link; fixes double free mess
+
+ * dbus/dbus-pending-call.c (dbus_pending_call_block): fix in case
+ where no reply was received
+
+ * dbus/dbus-connection.c (_dbus_pending_call_complete_and_unlock):
+ fix a refcount leak
+
+ * bus/signals.c (match_rule_matches): add special cases for the
+ bus driver, so you can match on sender/destination for it.
+
+ * dbus/dbus-sysdeps.c (_dbus_abort): print backtrace if
+ DBUS_PRINT_BACKTRACE is set
+
+ * dbus/dbus-internals.c: add pid to assertion failure messages
+
+ * dbus/dbus-connection.c: add message type code to the debug spew
+
+ * glib/dbus-gproxy.c (gproxy_get_match_rule): match rules want
+ sender=foo not service=foo
+
+ * dbus/dbus-bus.c (dbus_bus_get): if the activation bus is the
+ session bus but DBUS_SESSION_BUS_ADDRESS isn't set, use
+ DBUS_ACTIVATION_ADDRESS instead
+
+ * bus/activation.c: set DBUS_SESSION_BUS_ADDRESS,
+ DBUS_SYSTEM_BUS_ADDRESS if appropriate
+
+ * bus/bus.c (bus_context_new): handle OOM copying bus type into
+ context struct
+
+ * dbus/dbus-message.c (dbus_message_iter_get_object_path): new function
+ (dbus_message_iter_get_object_path_array): new function (half
+ finished, disabled for the moment)
+
+ * glib/dbus-gproxy.c (dbus_gproxy_end_call): properly handle
+ DBUS_MESSAGE_TYPE_ERROR
+
+ * tools/dbus-launch.c (babysit): support DBUS_DEBUG_OUTPUT to
+ avoid redirecting stderr to /dev/null
+ (babysit): close stdin if not doing the "exit_with_session" thing
+
+ * dbus/dbus-sysdeps.c (_dbus_become_daemon): delete some leftover
+ debug code; change DBUS_DEBUG_OUTPUT to only enable stderr, not
+ stdout/stdin, so things don't get confused
+
+ * bus/system.conf.in: fix to allow replies, I modified .conf
+ instead of .conf.in again.
+
2003-10-14 David Zeuthen <david@fubar.dk>
* python/dbus_bindings.pyx.in (MessageIter.get): fixed typo in
*/
if (!_dbus_setenv ("DBUS_ACTIVATION_ADDRESS", activation->server_address))
_dbus_exit (1);
-
+
type = bus_context_get_type (activation->context);
if (type != NULL)
{
if (!_dbus_setenv ("DBUS_BUS_TYPE", type))
_dbus_exit (1);
+
+ if (strcmp (type, "session") == 0)
+ {
+ if (!_dbus_setenv ("DBUS_SESSION_BUS_ADDRESS",
+ activation->server_address))
+ _dbus_exit (1);
+ }
+ else if (strcmp (type, "system") == 0)
+ {
+ if (!_dbus_setenv ("DBUS_SYSTEM_BUS_ADDRESS",
+ activation->server_address))
+ _dbus_exit (1);
+ }
}
}
{
int refcount;
char *type;
+ char *bus_env_var;
char *address;
char *pidfile;
DBusLoop *loop;
/* note that type may be NULL */
context->type = _dbus_strdup (bus_config_parser_get_type (parser));
+ if (bus_config_parser_get_type (parser) != NULL && context->type == NULL)
+ {
+ BUS_SET_OOM (error);
+ goto failed;
+ }
/* We have to build the address backward, so that
* <listen> later in the config file have priority
BusContext *context;
DBusHashTable *completed_by_user; /**< Number of completed connections for each UID */
DBusTimeout *expire_timeout; /**< Timeout for expiring incomplete connections. */
- int stamp; /**< Incrementing number */
+ int stamp; /**< Incrementing number */
BusExpireList *pending_replies; /**< List of pending replies */
};
return TRUE;
}
+static void
+bus_pending_reply_free (BusPendingReply *pending)
+{
+ _dbus_verbose ("Freeing pending reply %p, replier %p receiver %p serial %u\n",
+ pending,
+ pending->will_send_reply,
+ pending->will_get_reply,
+ pending->reply_serial);
+
+ dbus_free (pending);
+}
+
static dbus_bool_t
bus_pending_reply_send_no_reply (BusConnections *connections,
BusTransaction *transaction,
* leave it in the list to try expiring again later when we
* get more memory.
*/
+
+ _dbus_verbose ("Expiring pending reply %p, replier %p receiver %p serial %u\n",
+ pending,
+ pending->will_send_reply,
+ pending->will_get_reply,
+ pending->reply_serial);
+
transaction = bus_transaction_new (connections->context);
if (transaction == NULL)
return;
- if (bus_pending_reply_send_no_reply (connections,
- transaction,
- pending))
+ if (!bus_pending_reply_send_no_reply (connections,
+ transaction,
+ pending))
{
- _dbus_list_remove_link (&connections->pending_replies->items,
- link);
- dbus_free (pending);
bus_transaction_cancel_and_free (transaction);
+ return;
}
-
+
+ _dbus_list_remove_link (&connections->pending_replies->items,
+ link);
+ bus_pending_reply_free (pending);
bus_transaction_execute_and_free (transaction);
}
* do anything with it except check for pointer equality
*/
DBusList *link;
+
+ _dbus_verbose ("Dropping pending replies that involve connection %p\n",
+ connection);
link = _dbus_list_get_first_link (&connections->pending_replies->items);
while (link != NULL)
{
/* We don't need to track this pending reply anymore */
+ _dbus_verbose ("Dropping pending reply %p, replier %p receiver %p serial %u\n",
+ pending,
+ pending->will_send_reply,
+ pending->will_get_reply,
+ pending->reply_serial);
+
_dbus_list_remove_link (&connections->pending_replies->items,
link);
- dbus_free (pending);
+ bus_pending_reply_free (pending);
}
else if (pending->will_send_reply == connection)
{
/* The reply isn't going to be sent, so set things
* up so it will be expired right away
*/
-
+ _dbus_verbose ("Will expire pending reply %p, replier %p receiver %p serial %u\n",
+ pending,
+ pending->will_send_reply,
+ pending->will_get_reply,
+ pending->reply_serial);
+
pending->will_send_reply = NULL;
pending->expire_item.added_tv_sec = 0;
pending->expire_item.added_tv_usec = 0;
{
CancelPendingReplyData *d = data;
+ _dbus_verbose ("%s: d = %p\n", _DBUS_FUNCTION_NAME, d);
+
if (!_dbus_list_remove (&d->connections->pending_replies->items,
d->pending))
_dbus_assert_not_reached ("pending reply did not exist to be cancelled");
- dbus_free (d->pending); /* since it's been cancelled */
+ bus_pending_reply_free (d->pending); /* since it's been cancelled */
}
static void
{
CancelPendingReplyData *d = data;
+ _dbus_verbose ("%s: d = %p\n", _DBUS_FUNCTION_NAME, d);
+
/* d->pending should be either freed or still
* in the list of pending replies (owned by someone
* else)
return FALSE;
}
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+ /* so we can see a not-yet-added pending reply */
+ pending->expire_item.added_tv_sec = 1;
+ pending->expire_item.added_tv_usec = 1;
+#endif
+
+ pending->will_get_reply = will_get_reply;
+ pending->will_send_reply = will_send_reply;
+ pending->reply_serial = reply_serial;
+
cprd = dbus_new0 (CancelPendingReplyData, 1);
if (cprd == NULL)
{
BUS_SET_OOM (error);
- dbus_free (pending);
+ bus_pending_reply_free (pending);
return FALSE;
}
{
BUS_SET_OOM (error);
dbus_free (cprd);
- dbus_free (pending);
+ bus_pending_reply_free (pending);
return FALSE;
}
BUS_SET_OOM (error);
_dbus_list_remove (&connections->pending_replies->items, pending);
dbus_free (cprd);
- dbus_free (pending);
+ bus_pending_reply_free (pending);
return FALSE;
}
_dbus_get_current_time (&pending->expire_item.added_tv_sec,
&pending->expire_item.added_tv_usec);
- pending->will_get_reply = will_get_reply;
- pending->will_send_reply = will_send_reply;
- pending->reply_serial = reply_serial;
-
+ _dbus_verbose ("Added pending reply %p, replier %p receiver %p serial %u\n",
+ pending,
+ pending->will_send_reply,
+ pending->will_get_reply,
+ pending->reply_serial);
+
return TRUE;
}
{
CheckPendingReplyData *d = data;
+ _dbus_verbose ("%s: d = %p\n", _DBUS_FUNCTION_NAME, d);
+
_dbus_list_prepend_link (&d->connections->pending_replies->items,
d->link);
d->link = NULL;
{
CheckPendingReplyData *d = data;
+ _dbus_verbose ("%s: d = %p\n", _DBUS_FUNCTION_NAME, d);
+
if (d->link != NULL)
{
BusPendingReply *pending = d->link->data;
-
- dbus_free (pending);
+
+ _dbus_assert (_dbus_list_find_last (&d->connections->pending_replies->items,
+ pending) == NULL);
+
+ bus_pending_reply_free (pending);
_dbus_list_free_link (d->link);
}
pending->will_get_reply == receiving_reply &&
pending->will_send_reply == sending_reply)
{
- _dbus_verbose ("Found pending reply\n");
+ _dbus_verbose ("Found pending reply with serial %u\n", reply_serial);
break;
}
cprd->link = link;
cprd->connections = connections;
- _dbus_list_remove_link (&connections->pending_replies->items,
- link);
+ _dbus_list_unlink (&connections->pending_replies->items,
+ link);
+
+ _dbus_assert (_dbus_list_find_last (&connections->pending_replies->items,
+ link->data) == NULL);
return TRUE;
}
ch = dbus_new (CancelHook, 1);
if (ch == NULL)
return FALSE;
+
+ _dbus_verbose (" adding cancel hook function = %p data = %p\n",
+ cancel_function, data);
ch->cancel_function = cancel_function;
ch->data = data;
DBusString str;
BusRegistry *registry;
+ _dbus_assert (connection != NULL);
+
registry = bus_connection_get_registry (connection);
_dbus_string_init_const (&str, service_name);
* so FALSE if any of them don't match.
*/
+ /* sender/addressed_recipient of #NULL may mean bus driver,
+ * or for addressed_recipient may mean a message with no
+ * specific recipient (i.e. a signal)
+ */
+
if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
{
_dbus_assert (rule->message_type != DBUS_MESSAGE_TYPE_INVALID);
{
_dbus_assert (rule->sender != NULL);
- if (!connection_is_primary_owner (sender, rule->sender))
- return FALSE;
+ if (sender == NULL)
+ {
+ if (strcmp (rule->sender,
+ DBUS_SERVICE_ORG_FREEDESKTOP_DBUS) != 0)
+ return FALSE;
+ }
+ else
+ {
+ if (!connection_is_primary_owner (sender, rule->sender))
+ return FALSE;
+ }
}
if (rule->flags & BUS_MATCH_DESTINATION)
_dbus_assert (rule->destination != NULL);
- if (addressed_recipient == NULL)
- return FALSE;
-
destination = dbus_message_get_destination (message);
if (destination == NULL)
return FALSE;
- if (!connection_is_primary_owner (addressed_recipient, rule->destination))
- return FALSE;
+ if (addressed_recipient == NULL)
+ {
+ if (strcmp (rule->destination,
+ DBUS_SERVICE_ORG_FREEDESKTOP_DBUS) != 0)
+ return FALSE;
+ }
+ else
+ {
+ if (!connection_is_primary_owner (addressed_recipient, rule->destination))
+ return FALSE;
+ }
}
if (rule->flags & BUS_MATCH_PATH)
even if they aren't in here -->
<allow send_destination="org.freedesktop.DBus"/>
<allow receive_sender="org.freedesktop.DBus"/>
+ <!-- valid replies are always allowed -->
+ <allow requested_reply="true"/>
</policy>
<!-- Config files are placed here that among other things, punch
if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
{
+ _dbus_verbose ("Filling in system bus address...\n");
+
if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SYSTEM],
"DBUS_SYSTEM_BUS_ADDRESS"))
return FALSE;
_dbus_strdup (DBUS_SYSTEM_BUS_DEFAULT_ADDRESS);
if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL)
return FALSE;
+
+ _dbus_verbose (" used default system bus \"%s\"\n",
+ bus_connection_addresses[DBUS_BUS_SYSTEM]);
}
+ else
+ _dbus_verbose (" used env var system bus \"%s\"\n",
+ bus_connection_addresses[DBUS_BUS_SYSTEM]);
}
if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL)
{
+ _dbus_verbose ("Filling in session bus address...\n");
+
if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SESSION],
"DBUS_SESSION_BUS_ADDRESS"))
return FALSE;
+ _dbus_verbose (" \"%s\"\n", bus_connection_addresses[DBUS_BUS_SESSION] ?
+ bus_connection_addresses[DBUS_BUS_SESSION] : "none set");
}
if (bus_connection_addresses[DBUS_BUS_ACTIVATION] == NULL)
{
+ _dbus_verbose ("Filling in activation bus address...\n");
+
if (!get_from_env (&bus_connection_addresses[DBUS_BUS_ACTIVATION],
"DBUS_ACTIVATION_ADDRESS"))
return FALSE;
+
+ _dbus_verbose (" \"%s\"\n", bus_connection_addresses[DBUS_BUS_ACTIVATION] ?
+ bus_connection_addresses[DBUS_BUS_ACTIVATION] : "none set");
}
s = _dbus_getenv ("DBUS_ACTIVATION_BUS_TYPE");
if (s != NULL)
{
+ _dbus_verbose ("Bus activation type was set to \"%s\"\n", s);
+
if (strcmp (s, "system") == 0)
activation_bus_type = DBUS_BUS_SYSTEM;
else if (strcmp (s, "session") == 0)
address_type = type;
/* Use the real type of the activation bus for getting its
- * connection. (If the activating bus isn't a well-known
- * bus then activation_bus_type == DBUS_BUS_ACTIVATION)
+ * connection, but only if the real type's address is available. (If
+ * the activating bus isn't a well-known bus then
+ * activation_bus_type == DBUS_BUS_ACTIVATION)
*/
- if (type == DBUS_BUS_ACTIVATION)
+ if (type == DBUS_BUS_ACTIVATION &&
+ bus_connection_addresses[activation_bus_type] != NULL)
type = activation_bus_type;
if (bus_connections[type] != NULL)
_dbus_connection_wakeup_mainloop (connection);
- _dbus_verbose ("Message %p (%s) added to incoming queue %p, %d incoming\n",
+ _dbus_verbose ("Message %p (%d %s '%s') added to incoming queue %p, %d incoming\n",
message,
+ dbus_message_get_type (message),
dbus_message_get_interface (message) ?
dbus_message_get_interface (message) :
"no interface",
+ dbus_message_get_signature (message),
connection,
connection->n_incoming);
}
connection->n_outgoing -= 1;
- _dbus_verbose ("Message %p (%s) removed from outgoing queue %p, %d left to send\n",
+ _dbus_verbose ("Message %p (%d %s '%s') removed from outgoing queue %p, %d left to send\n",
message,
+ dbus_message_get_type (message),
dbus_message_get_interface (message) ?
dbus_message_get_interface (message) :
"no interface",
+ dbus_message_get_signature (message),
connection, connection->n_outgoing);
/* Save this link in the link cache also */
message = pending->timeout_link->data;
_dbus_list_clear (&pending->timeout_link);
}
+ else
+ dbus_message_ref (message);
- _dbus_verbose (" handing message %p to pending call\n", message);
+ _dbus_verbose (" handing message %p (%s) to pending call serial %u\n",
+ message,
+ dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN ?
+ "method return" :
+ dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR ?
+ "error" : "other type",
+ pending->reply_serial);
_dbus_assert (pending->reply == NULL);
+ _dbus_assert (pending->reply_serial == dbus_message_get_reply_serial (message));
pending->reply = message;
- dbus_message_ref (pending->reply);
dbus_pending_call_ref (pending); /* in case there's no app with a ref held */
_dbus_connection_detach_pending_call_and_unlock (pending->connection, pending);
connection->n_outgoing += 1;
- _dbus_verbose ("Message %p (%s) added to outgoing queue %p, %d pending to send\n",
+ _dbus_verbose ("Message %p (%d %s '%s') added to outgoing queue %p, %d pending to send\n",
message,
+ dbus_message_get_type (message),
dbus_message_get_interface (message) ?
dbus_message_get_interface (message) :
"no interface",
+ dbus_message_get_signature (message),
connection,
connection->n_outgoing);
link = _dbus_list_pop_first_link (&connection->incoming_messages);
connection->n_incoming -= 1;
- _dbus_verbose ("Message %p (%s) removed from incoming queue %p, %d incoming\n",
+ _dbus_verbose ("Message %p (%d %s '%s') removed from incoming queue %p, %d incoming\n",
link->data,
+ dbus_message_get_type (link->data),
dbus_message_get_interface (link->data) ?
dbus_message_get_interface (link->data) :
"no interface",
+ dbus_message_get_signature (link->data),
connection, connection->n_incoming);
return link;
message_link);
connection->n_incoming += 1;
- _dbus_verbose ("Message %p (%s) put back into queue %p, %d incoming\n",
+ _dbus_verbose ("Message %p (%d %s '%s') put back into queue %p, %d incoming\n",
message_link->data,
+ dbus_message_get_type (message_link->data),
dbus_message_get_interface (message_link->data) ?
dbus_message_get_interface (message_link->data) :
"no interface",
+ dbus_message_get_signature (message_link->data),
connection, connection->n_incoming);
}
/* We're still protected from dispatch() reentrancy here
* since we acquired the dispatcher
*/
- _dbus_verbose (" running object path dispatch on message %p (%s)\n",
+ _dbus_verbose (" running object path dispatch on message %p (%d %s '%s')\n",
message,
+ dbus_message_get_type (message),
dbus_message_get_interface (message) ?
dbus_message_get_interface (message) :
"no interface");
result = DBUS_HANDLER_RESULT_HANDLED;
}
- _dbus_verbose (" done dispatching %p (%s) on connection %p\n", message,
+ _dbus_verbose (" done dispatching %p (%d %s '%s') on connection %p\n", message,
+ dbus_message_get_type (message),
dbus_message_get_interface (message) ?
dbus_message_get_interface (message) :
"no interface",
+ dbus_message_get_signature (message),
connection);
out:
if (result == DBUS_HANDLER_RESULT_NEED_MEMORY)
{
+ _dbus_verbose ("out of memory in %s\n", _DBUS_FUNCTION_NAME);
+
/* Put message back, and we'll start over.
* Yes this means handlers must be idempotent if they
* don't return HANDLED; c'est la vie.
}
else
{
+ _dbus_verbose ("Done with message in %s\n", _DBUS_FUNCTION_NAME);
+
if (connection->exit_on_disconnect &&
dbus_message_is_signal (message,
DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL,
va_start (args, format);
vfprintf (stderr, format, args);
va_end (args);
+
+ fflush (stderr);
}
/**
#ifndef DBUS_DISABLE_CHECKS
/** String used in _dbus_return_if_fail macro */
const char _dbus_return_if_fail_warning_format[] =
-"Arguments to %s() were incorrect, assertion \"%s\" failed in file %s line %d.\n"
+"%lu: arguments to %s() were incorrect, assertion \"%s\" failed in file %s line %d.\n"
"This is normally a bug in some application using the D-BUS library.\n";
#endif
{
if (!condition)
{
- _dbus_warn ("Assertion failed \"%s\" file \"%s\" line %d process %lu\n",
- condition_text, file, line, _dbus_getpid ());
+ _dbus_warn ("%lu: assertion failed \"%s\" file \"%s\" line %d\n",
+ _dbus_getpid (), condition_text, file, line);
_dbus_abort ();
}
}
#else
extern const char _dbus_return_if_fail_warning_format[];
-#define _dbus_return_if_fail(condition) do { \
- if (!(condition)) { \
- _dbus_warn (_dbus_return_if_fail_warning_format, \
- _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \
- return; \
+#define _dbus_return_if_fail(condition) do { \
+ if (!(condition)) { \
+ _dbus_warn (_dbus_return_if_fail_warning_format, \
+ _dbus_getpid (), _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \
+ return; \
} } while (0)
-#define _dbus_return_val_if_fail(condition, val) do { \
- if (!(condition)) { \
- _dbus_warn (_dbus_return_if_fail_warning_format, \
- _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \
- return (val); \
+#define _dbus_return_val_if_fail(condition, val) do { \
+ if (!(condition)) { \
+ _dbus_warn (_dbus_return_if_fail_warning_format, \
+ _dbus_getpid (), _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \
+ return (val); \
} } while (0)
#endif /* !DBUS_DISABLE_ASSERT */
if (!dbus_message_iter_append_string (&iter, va_arg (var_args, const char *)))
goto errorout;
break;
+ case DBUS_TYPE_OBJECT_PATH:
+
+ break;
case DBUS_TYPE_NAMED:
{
const char *name;
_dbus_return_val_if_fail (dbus_message_iter_check (real), DBUS_TYPE_INVALID);
if (real->pos >= real->end)
- return DBUS_TYPE_INVALID;
+ {
+ _dbus_verbose (" iterator at or beyond end of message\n");
+ return DBUS_TYPE_INVALID;
+ }
pos = dbus_message_iter_get_data_start (real, &type);
pos, NULL);
}
+#if 0
+/**
+ * @todo FIXME to finish this _dbus_demarshal_object_path() needs
+ * to not explode the path.
+ *
+ * Returns the object path value that an iterator may point to.
+ * Note that you need to check that the iterator points to
+ * an object path value before using this function.
+ *
+ * @see dbus_message_iter_get_arg_type
+ * @param iter the message iter
+ * @returns the path
+ */
+char *
+dbus_message_iter_get_object_path (DBusMessageIter *iter)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+ int type, pos;
+
+ _dbus_return_val_if_fail (dbus_message_iter_check (real), NULL);
+
+ pos = dbus_message_iter_get_data_start (real, &type);
+
+ _dbus_assert (type == DBUS_TYPE_OBJECT_PATH);
+
+ return _dbus_demarshal_object_path (&real->message->body, real->message->byte_order,
+ pos, NULL);
+}
+#endif
+
/**
* Returns the name and data from a named type that an
* iterator may point to. Note that you need to check that
/**
* Returns the string array that the iterator may point to.
* Note that you need to check that the iterator points
- * to a byte array prior to using this function.
+ * to a string array prior to using this function.
*
* The returned value is a #NULL-terminated array of strings.
* Each string is a separate malloc block, and the array
return TRUE;
}
+#if 0
+/**
+ * @todo FIXME to implement this _dbus_demarshal_object_path_array()
+ * needs implementing
+ *
+ * Returns the object path array that the iterator may point to.
+ * Note that you need to check that the iterator points
+ * to an object path array prior to using this function.
+ *
+ * The returned value is a #NULL-terminated array of strings.
+ * Each string is a separate malloc block, and the array
+ * itself is a malloc block. You can free this type of
+ * array with dbus_free_string_array().
+ *
+ * @param iter the iterator
+ * @param value return location for string values
+ * @param len return location for length of byte array
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+dbus_message_iter_get_object_path_array (DBusMessageIter *iter,
+ char ***value,
+ int *len)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+ int type, pos;
+
+ _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE);
+
+ pos = dbus_message_iter_get_data_start (real, &type);
+
+ _dbus_assert (type == DBUS_TYPE_ARRAY);
+
+ type = iter_get_array_type (real, NULL);
+ _dbus_assert (type == DBUS_TYPE_OBJECT_PATH);
+
+ if (!_dbus_demarshal_object_path_array (&real->message->body, real->message->byte_order,
+ pos, NULL, value, len))
+ return FALSE;
+ else
+ return TRUE;
+}
+#endif
+
/**
* Returns the key name fot the dict entry that an iterator
* may point to. Note that you need to check that the iterator
/**
* Appends a UTF-8 string to the message.
*
+ * @todo add return_val_if_fail(UTF-8 is valid)
+ *
* @param iter an iterator pointing to the end of the message
* @param value the string
* @returns #TRUE on success
DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
_dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE);
-
+
if (!dbus_message_iter_append_type (real, DBUS_TYPE_STRING))
return FALSE;
fields[field].name_offset = pos;
fields[field].value_offset = _DBUS_ALIGN_VALUE (pos, 4);
- _dbus_verbose ("Found reply serial at offset %d\n",
+ _dbus_verbose ("Found reply serial %u at offset %d\n",
+ _dbus_demarshal_uint32 (data,
+ byte_order,
+ fields[field].value_offset,
+ NULL),
fields[field].value_offset);
break;
const unsigned char our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
char sig[64];
const char *s;
+ char *t;
+ DBusError error;
_dbus_assert (sizeof (DBusMessageRealIter) <= sizeof (DBusMessageIter));
_dbus_assert (strcmp (name1, name2) == 0);
- dbus_message_unref (message);
+ dbus_message_unref (message);
dbus_message_unref (copy);
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"data", 5);
message_iter_test (message);
-
+
/* Message loader test */
_dbus_message_lock (message);
loader = _dbus_message_loader_new ();
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
+ copy = dbus_message_copy (message); /* save for tests below */
dbus_message_unref (message);
/* Now pop back the message */
dbus_message_unref (message);
_dbus_message_loader_unref (loader);
+ message = dbus_message_new_method_return (copy);
+ if (message == NULL)
+ _dbus_assert_not_reached ("out of memory\n");
+ dbus_message_unref (copy);
+
+ if (!dbus_message_append_args (message,
+ DBUS_TYPE_STRING, "hello",
+ DBUS_TYPE_INVALID))
+ _dbus_assert_not_reached ("no memory");
+
+ if (!dbus_message_has_signature (message, "s"))
+ _dbus_assert_not_reached ("method return has wrong signature");
+
+ dbus_error_init (&error);
+ if (!dbus_message_get_args (message, &error, DBUS_TYPE_STRING,
+ &t, DBUS_TYPE_INVALID))
+
+ {
+ _dbus_warn ("Failed to get expected string arg: %s\n", error.message);
+ exit (1);
+ }
+ dbus_free (t);
+
+ dbus_message_unref (message);
+
/* Now load every message in test_data_dir if we have one */
if (test_data_dir == NULL)
return TRUE;
va_list var_args);
-
-void dbus_message_iter_init (DBusMessage *message,
- DBusMessageIter *iter);
-dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter);
-dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter);
-int dbus_message_iter_get_arg_type (DBusMessageIter *iter);
-int dbus_message_iter_get_array_type (DBusMessageIter *iter);
-unsigned char dbus_message_iter_get_byte (DBusMessageIter *iter);
-dbus_bool_t dbus_message_iter_get_boolean (DBusMessageIter *iter);
-dbus_int32_t dbus_message_iter_get_int32 (DBusMessageIter *iter);
-dbus_uint32_t dbus_message_iter_get_uint32 (DBusMessageIter *iter);
+void dbus_message_iter_init (DBusMessage *message,
+ DBusMessageIter *iter);
+dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter);
+dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter);
+int dbus_message_iter_get_arg_type (DBusMessageIter *iter);
+int dbus_message_iter_get_array_type (DBusMessageIter *iter);
+unsigned char dbus_message_iter_get_byte (DBusMessageIter *iter);
+dbus_bool_t dbus_message_iter_get_boolean (DBusMessageIter *iter);
+dbus_int32_t dbus_message_iter_get_int32 (DBusMessageIter *iter);
+dbus_uint32_t dbus_message_iter_get_uint32 (DBusMessageIter *iter);
#ifdef DBUS_HAVE_INT64
-dbus_int64_t dbus_message_iter_get_int64 (DBusMessageIter *iter);
-dbus_uint64_t dbus_message_iter_get_uint64 (DBusMessageIter *iter);
+dbus_int64_t dbus_message_iter_get_int64 (DBusMessageIter *iter);
+dbus_uint64_t dbus_message_iter_get_uint64 (DBusMessageIter *iter);
#endif /* DBUS_HAVE_INT64 */
-double dbus_message_iter_get_double (DBusMessageIter *iter);
-char * dbus_message_iter_get_string (DBusMessageIter *iter);
-char * dbus_message_iter_get_dict_key (DBusMessageIter *iter);
-dbus_bool_t dbus_message_iter_get_named (DBusMessageIter *iter,
- char **name,
- unsigned char **value,
- int *len);
+double dbus_message_iter_get_double (DBusMessageIter *iter);
+char * dbus_message_iter_get_string (DBusMessageIter *iter);
+char * dbus_message_iter_get_object_path (DBusMessageIter *iter);
+char * dbus_message_iter_get_dict_key (DBusMessageIter *iter);
+dbus_bool_t dbus_message_iter_get_named (DBusMessageIter *iter,
+ char **name,
+ unsigned char **value,
+ int *len);
void dbus_message_iter_init_array_iterator (DBusMessageIter *iter,
DBusMessageIter *array_iter,
dbus_bool_t dbus_message_iter_get_string_array (DBusMessageIter *iter,
char ***value,
int *len);
+dbus_bool_t dbus_message_iter_get_object_path_array (DBusMessageIter *iter,
+ char ***value,
+ int *len);
void dbus_message_append_iter_init (DBusMessage *message,
if (dbus_pending_call_get_completed (pending))
return;
-
+
+ /* message may be NULL if no reply */
message = _dbus_connection_block_for_reply (pending->connection,
pending->reply_serial,
dbus_timeout_get_interval (pending->timeout));
_dbus_connection_lock (pending->connection);
_dbus_pending_call_complete_and_unlock (pending, message);
- dbus_message_unref (message);
+ if (message)
+ dbus_message_unref (message);
}
static DBusDataSlotAllocator slot_allocator;
void
_dbus_abort (void)
{
+#ifdef DBUS_ENABLE_VERBOSE_MODE
+ const char *s;
+ s = _dbus_getenv ("DBUS_PRINT_BACKTRACE");
+ if (s && *s)
+ _dbus_print_backtrace ();
+#endif
abort ();
_exit (1); /* in case someone manages to ignore SIGABRT */
}
{
const char *s;
pid_t child_pid;
+ int dev_null_fd;
+
+ _dbus_verbose ("Becoming a daemon...\n");
+ _dbus_verbose ("chdir to /\n");
if (chdir ("/") < 0)
{
dbus_set_error (error, DBUS_ERROR_FAILED,
return FALSE;
}
+ _dbus_verbose ("forking...\n");
switch ((child_pid = fork ()))
{
case -1:
+ _dbus_verbose ("fork failed\n");
dbus_set_error (error, _dbus_error_from_errno (errno),
"Failed to fork daemon: %s", _dbus_strerror (errno));
return FALSE;
break;
case 0:
+ _dbus_verbose ("in child, closing std file descriptors\n");
-
- s = _dbus_getenv ("DBUS_DEBUG_DAEMONIZE");
- if (s != NULL)
- kill (_dbus_getpid (), SIGSTOP);
+ /* silently ignore failures here, if someone
+ * doesn't have /dev/null we may as well try
+ * to continue anyhow
+ */
- s = _dbus_getenv ("DBUS_DEBUG_OUTPUT");
- if (s == NULL || *s == '\0')
+ dev_null_fd = open ("/dev/null", O_RDWR);
+ if (dev_null_fd >= 0)
{
- int dev_null_fd;
-
- /* silently ignore failures here, if someone
- * doesn't have /dev/null we may as well try
- * to continue anyhow
- */
-
- dev_null_fd = open ("/dev/null", O_RDWR);
- if (dev_null_fd >= 0)
- {
- dup2 (dev_null_fd, 0);
- dup2 (dev_null_fd, 1);
- dup2 (dev_null_fd, 2);
- }
+ dup2 (dev_null_fd, 0);
+ dup2 (dev_null_fd, 1);
+
+ s = _dbus_getenv ("DBUS_DEBUG_OUTPUT");
+ if (s == NULL || *s == '\0')
+ dup2 (dev_null_fd, 2);
+ else
+ _dbus_verbose ("keeping stderr open due to DBUS_DEBUG_OUTPUT\n");
}
/* Get a predictable umask */
+ _dbus_verbose ("setting umask\n");
umask (022);
break;
default:
if (pidfile)
{
+ _dbus_verbose ("parent writing pid file\n");
if (!_dbus_write_pid_file (pidfile,
child_pid,
error))
{
+ _dbus_verbose ("pid file write failed, killing child\n");
kill (child_pid, SIGTERM);
return FALSE;
}
}
+ _dbus_verbose ("parent exiting\n");
_exit (0);
break;
}
+ _dbus_verbose ("calling setsid()\n");
if (setsid () == -1)
_dbus_assert_not_reached ("setsid() failed");
we need to have a test for it in the test suite.
- the max_replies_per_connection resource limit isn't implemented
+
+ - array lengths should probably be returned as size_t rather than int
+ (though they are kind of a pita to pass in as size_t with the
+ varargs, so maybe not - what does glib do with g_object_get()?)
+
+ - the varargs dbus_message_get_args() needs to support OBJECT_PATH
+ and OBJECT_PATH_ARRAY
/* FIXME Some sort of escaping is required here I think */
if (proxy->service)
- return g_strdup_printf ("type='signal',service='%s',path='%s',interface='%s'",
+ return g_strdup_printf ("type='signal',sender='%s',path='%s',interface='%s'",
proxy->service, proxy->path, proxy->interface);
else
return g_strdup_printf ("type='signal',path='%s',interface='%s'",
g_assert (message != NULL);
dbus_error_init (&derror);
- va_start (args, first_arg_type);
- if (!dbus_message_get_args_valist (message, &derror, first_arg_type, args))
+
+ switch (dbus_message_get_type (message))
{
+ case DBUS_MESSAGE_TYPE_METHOD_RETURN:
+ va_start (args, first_arg_type);
+ if (!dbus_message_get_args_valist (message, &derror, first_arg_type, args))
+ {
+ va_end (args);
+ goto error;
+ }
va_end (args);
+
+ return TRUE;
+
+ case DBUS_MESSAGE_TYPE_ERROR:
+ dbus_set_error_from_message (&derror, message);
goto error;
- }
- va_end (args);
- return TRUE;
+ default:
+ dbus_set_error (&derror, DBUS_ERROR_FAILED,
+ "Reply was neither a method return nor an exception");
+ goto error;
+ }
error:
dbus_set_g_error (error, &derror);
function die()
{
+ if ! test -z "$DBUS_SESSION_BUS_PID" ; then
+ kill -9 $DBUS_SESSION_BUS_PID
+ fi
echo $SCRIPTNAME: $* >&2
exit 1
}
fi
CONFIG_FILE=./run-test.conf
+SERVICE_DIR="$DBUS_TOP_BUILDDIR/test/data/valid-service-files"
+ESCAPED_SERVICE_DIR=`echo $SERVICE_DIR | sed -e 's/\//\\\\\\//g'`
+echo "escaped service dir is: $ESCAPED_SERVICE_DIR"
## create a configuration file based on the standard session.conf
cat $DBUS_TOP_BUILDDIR/bus/session.conf | \
- sed -e 's/<servicedir>.*$//g' | \
- sed -e 's/<include.*$//g' \
+ sed -e 's/<servicedir>.*$/<servicedir>'$ESCAPED_SERVICE_DIR'<\/servicedir>/g' | \
+ sed -e 's/<include.*$//g' \
> $CONFIG_FILE
echo "Created configuration file $CONFIG_FILE"
GMainLoop *loop;
GError *error;
DBusGProxy *driver;
+ DBusGProxy *proxy;
DBusPendingCall *call;
char **service_list;
int service_list_len;
int i;
-
+ dbus_uint32_t result;
+ char *str;
+
g_type_init ();
loop = g_main_loop_new (NULL, FALSE);
dbus_free_string_array (service_list);
+ /* Test handling of unknown method */
+ call = dbus_gproxy_begin_call (driver, "ThisMethodDoesNotExist",
+ DBUS_TYPE_STRING,
+ "blah blah blah blah blah",
+ DBUS_TYPE_INT32,
+ 10,
+ DBUS_TYPE_INVALID);
+
+ error = NULL;
+ if (dbus_gproxy_end_call (driver, call, &error,
+ DBUS_TYPE_INVALID))
+ {
+ g_printerr ("Calling nonexistent method succeeded!\n");
+ exit (1);
+ }
+
+ g_print ("Got EXPECTED error from calling unknown method: %s\n",
+ error->message);
+ g_error_free (error);
+
+ /* Activate a service */
+ call = dbus_gproxy_begin_call (driver, "ActivateService",
+ DBUS_TYPE_STRING,
+ "org.freedesktop.DBus.TestSuiteEchoService",
+ DBUS_TYPE_UINT32,
+ 0,
+ DBUS_TYPE_INVALID);
+
+ error = NULL;
+ if (!dbus_gproxy_end_call (driver, call, &error,
+ DBUS_TYPE_UINT32, &result,
+ DBUS_TYPE_INVALID))
+ {
+ g_printerr ("Failed to complete Activate call: %s\n",
+ error->message);
+ g_error_free (error);
+ exit (1);
+ }
+
+ g_print ("Activation of echo service = 0x%x\n", result);
+
+ /* Activate a service again */
+ call = dbus_gproxy_begin_call (driver, "ActivateService",
+ DBUS_TYPE_STRING,
+ "org.freedesktop.DBus.TestSuiteEchoService",
+ DBUS_TYPE_UINT32,
+ 0,
+ DBUS_TYPE_INVALID);
+
+ error = NULL;
+ if (!dbus_gproxy_end_call (driver, call, &error,
+ DBUS_TYPE_UINT32, &result,
+ DBUS_TYPE_INVALID))
+ {
+ g_printerr ("Failed to complete Activate call: %s\n",
+ error->message);
+ g_error_free (error);
+ exit (1);
+ }
+
+ g_print ("Duplicate activation of echo service = 0x%x\n", result);
+
+ /* Talk to the new service */
+
+ proxy = dbus_gproxy_new_for_service (connection,
+ "org.freedesktop.DBus.TestSuiteEchoService",
+ "/fixme/the/test/service/ignores/this", /* FIXME */
+ "org.freedesktop.TestSuite");
+
+ call = dbus_gproxy_begin_call (proxy, "Echo",
+ DBUS_TYPE_STRING,
+ "my string hello",
+ DBUS_TYPE_INVALID);
+
+ error = NULL;
+ if (!dbus_gproxy_end_call (proxy, call, &error,
+ DBUS_TYPE_STRING, &str,
+ DBUS_TYPE_INVALID))
+ {
+ g_printerr ("Failed to complete Echo call: %s\n",
+ error->message);
+ g_error_free (error);
+ exit (1);
+ }
+
+ g_print ("String echoed = \"%s\"\n", str);
+ dbus_free (str);
+
g_object_unref (G_OBJECT (driver));
+ g_object_unref (G_OBJECT (proxy));
g_print ("Successfully completed %s\n", argv[0]);
{
DBusError error;
DBusMessage *reply;
- DBusMessageIter iter;
char *s;
dbus_error_init (&error);
reply = dbus_message_new_method_return (message);
if (reply == NULL)
die ("No memory\n");
-
- dbus_message_append_iter_init (message, &iter);
- if (!dbus_message_iter_append_string (&iter, s))
+ if (!dbus_message_append_args (reply,
+ DBUS_TYPE_STRING, s,
+ DBUS_TYPE_INVALID))
die ("No memory");
-
+
if (!dbus_connection_send (connection, reply, NULL))
die ("No memory\n");
+
+ fprintf (stderr, "Echo service echoed string: \"%s\"\n", s);
dbus_free (s);
dbus_message_unref (reply);
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
goto again;
else
{
- fprintf (stderr, "Failed to write data to pipe!\n");
+ fprintf (stderr, "Failed to write data to pipe! %s\n",
+ strerror (errno));
exit (1); /* give up, we suck */
}
}
long val;
char *end;
int dev_null_fd;
+ const char *s;
+
+ verbose ("babysitting, exit_with_session = %d, child_pid = %ld, read_bus_pid_fd = %d, write_bus_pid_fd = %d\n",
+ exit_with_session, (long) child_pid, read_bus_pid_fd, write_bus_pid_fd);
/* We chdir ("/") since we are persistent and daemon-like, and fork
* again so dbus-launch can reap the parent. However, we don't
exit (1);
}
- /* Move stdout/stderr so we don't block an "eval" or otherwise
- * lock up.
+ /* Close stdout/stderr so we don't block an "eval" or otherwise
+ * lock up. stdout is still chaining through to dbus-launch
+ * and in turn to the parent shell.
*/
dev_null_fd = open ("/dev/null", O_RDWR);
if (dev_null_fd >= 0)
{
+ if (!exit_with_session)
+ dup2 (dev_null_fd, 0);
dup2 (dev_null_fd, 1);
- dup2 (dev_null_fd, 2);
+ s = getenv ("DBUS_DEBUG_OUTPUT");
+ if (s == NULL || *s == '\0')
+ dup2 (dev_null_fd, 2);
}
else
{
}
verbose ("dbus-launch exiting\n");
+
+ fflush (stdout);
+ fflush (stderr);
+ close (1);
+ close (2);
exit (0);
}
projects / platform / upstream / dbus.git / commitdiff