/**
* Creates a new pending reply object.
*
* @param connection connection where reply will arrive
* @param timeout_milliseconds length of timeout, -1 for default
* @param timeout_handler timeout handler, takes pending call as data
* @returns a new #DBusPendingCall or #NULL if no memory.
*/
DBusPendingCall*
_dbus_pending_call_new_unlocked (DBusConnection *connection,
int timeout_milliseconds,
DBusTimeoutHandler timeout_handler)
{
DBusPendingCall *pending;
DBusTimeout *timeout;
_dbus_assert (timeout_milliseconds >= 0 || timeout_milliseconds == -1);
if (timeout_milliseconds == -1)
timeout_milliseconds = _DBUS_DEFAULT_TIMEOUT_VALUE;
/* it would probably seem logical to pass in _DBUS_INT_MAX for
* infinite timeout, but then math in
* _dbus_connection_block_for_reply would get all overflow-prone, so
* smack that down.
*/
if (timeout_milliseconds > _DBUS_ONE_HOUR_IN_MILLISECONDS * 6)
timeout_milliseconds = _DBUS_ONE_HOUR_IN_MILLISECONDS * 6;
if (!dbus_pending_call_allocate_data_slot (¬ify_user_data_slot))
return NULL;
pending = dbus_new0 (DBusPendingCall, 1);
if (pending == NULL)
{
dbus_pending_call_free_data_slot (¬ify_user_data_slot);
return NULL;
}
timeout = _dbus_timeout_new (timeout_milliseconds,
timeout_handler,
pending, NULL);
if (timeout == NULL)
{
dbus_pending_call_free_data_slot (¬ify_user_data_slot);
dbus_free (pending);
return NULL;
}
pending->refcount.value = 1;
pending->connection = connection;
_dbus_connection_ref_unlocked (pending->connection);
pending->timeout = timeout;
_dbus_data_slot_list_init (&pending->slot_list);
return pending;
}
/**
* Creates a new pending reply object.
*
* @param connection connection where reply will arrive
* @param timeout_milliseconds length of timeout, -1 (or
* #DBUS_TIMEOUT_USE_DEFAULT) for default,
* #DBUS_TIMEOUT_INFINITE for no timeout
* @param timeout_handler timeout handler, takes pending call as data
* @returns a new #DBusPendingCall or #NULL if no memory.
*/
DBusPendingCall*
_dbus_pending_call_new_unlocked (DBusConnection *connection,
int timeout_milliseconds,
DBusTimeoutHandler timeout_handler)
{
DBusPendingCall *pending;
DBusTimeout *timeout;
_dbus_assert (timeout_milliseconds >= 0 || timeout_milliseconds == -1);
if (timeout_milliseconds == -1)
timeout_milliseconds = _DBUS_DEFAULT_TIMEOUT_VALUE;
if (!dbus_pending_call_allocate_data_slot (¬ify_user_data_slot))
return NULL;
pending = dbus_new0 (DBusPendingCall, 1);
if (pending == NULL)
{
dbus_pending_call_free_data_slot (¬ify_user_data_slot);
return NULL;
}
if (timeout_milliseconds != DBUS_TIMEOUT_INFINITE)
{
timeout = _dbus_timeout_new (timeout_milliseconds,
timeout_handler,
pending, NULL);
if (timeout == NULL)
{
dbus_pending_call_free_data_slot (¬ify_user_data_slot);
dbus_free (pending);
return NULL;
}
pending->timeout = timeout;
}
else
{
pending->timeout = NULL;
}
_dbus_atomic_inc (&pending->refcount);
pending->connection = connection;
_dbus_connection_ref_unlocked (pending->connection);
_dbus_data_slot_list_init (&pending->slot_list);
_dbus_pending_call_trace_ref (pending, 0, 1, "new_unlocked");
return pending;
}
static void
teardown (Fixture *f,
gconstpointer data)
{
if (f->server_connection != NULL)
{
dbus_connection_close (f->server_connection);
dbus_connection_unref (f->server_connection);
}
if (f->connection != NULL)
{
dbus_connection_close (f->connection);
dbus_connection_unref (f->connection);
}
if (f->server != NULL)
{
dbus_server_disconnect (f->server);
dbus_server_unref (f->server);
}
dbus_connection_free_data_slot (&connection_slot);
dbus_server_free_data_slot (&server_slot);
dbus_message_free_data_slot (&message_slot);
dbus_pending_call_free_data_slot (&pending_call_slot);
_dbus_loop_unref (f->loop);
dbus_error_free (&f->e);
}
static void
_dbus_pending_call_last_unref (DBusPendingCall *pending)
{
DBusConnection *connection;
/* If we get here, we should be already detached
* from the connection, or never attached.
*/
_dbus_assert (!pending->timeout_added);
connection = pending->connection;
/* this assumes we aren't holding connection lock... */
_dbus_data_slot_list_free (&pending->slot_list);
if (pending->timeout != NULL)
_dbus_timeout_unref (pending->timeout);
if (pending->timeout_link)
{
dbus_message_unref ((DBusMessage *)pending->timeout_link->data);
_dbus_list_free_link (pending->timeout_link);
pending->timeout_link = NULL;
}
if (pending->reply)
{
dbus_message_unref (pending->reply);
pending->reply = NULL;
}
dbus_free (pending);
dbus_pending_call_free_data_slot (¬ify_user_data_slot);
/* connection lock should not be held. */
/* Free the connection last to avoid a weird state while
* calling out to application code where the pending exists
* but not the connection.
*/
dbus_connection_unref (connection);
}
/* This test outputs TAP syntax: http://testanything.org/ */
int
main (int argc, char *argv[])
{
dbus_int32_t slot_connection = -1;
dbus_int32_t slot_message = -1;
dbus_int32_t slot_pending = -1;
DBusError error;
DBusConnection *conn;
DBusMessage *method;
DBusPendingCall *pending;
DBusMessage *reply;
printf ("# Testing pending call error\n");
dbus_connection_allocate_data_slot (&slot_connection);
dbus_message_allocate_data_slot (&slot_message);
dbus_pending_call_allocate_data_slot (&slot_pending);
dbus_error_init (&error);
conn = dbus_bus_get_private (DBUS_BUS_SESSION, &error);
dbus_connection_set_data (conn, slot_connection, (void*)"connection", free_data);
++count;
dbus_connection_set_exit_on_disconnect (conn, FALSE);
method = dbus_message_new_method_call ("org.freedesktop.TestSuiteEchoService",
"/org/freedesktop/TestSuite",
"org.freedesktop.TestSuite",
"Exit");
dbus_message_set_data (method, slot_message, (void*)"method", free_data);
++count;
dbus_connection_send_with_reply (conn, method, &pending, -1);
dbus_message_unref (method);
dbus_pending_call_set_data (pending, slot_pending, (void*)"pending", free_data);
++count;
dbus_connection_close (conn);
dbus_pending_call_block (pending);
reply = dbus_pending_call_steal_reply (pending);
dbus_pending_call_unref (pending);
if (reply == NULL)
{
printf ("Bail out! Reply is NULL ***\n");
exit (1);
}
dbus_message_set_data (reply, slot_message, (void*)"reply", free_data);
++count;
if (dbus_message_get_type (reply) != DBUS_MESSAGE_TYPE_ERROR)
{
printf ("Bail out! Reply is not error ***\n");
exit (1);
}
dbus_message_unref (reply);
dbus_connection_unref (conn);
dbus_connection_free_data_slot (&slot_connection);
dbus_message_free_data_slot (&slot_message);
dbus_pending_call_free_data_slot (&slot_pending);
if (count != 0)
{
printf ("not ok # Not all refs were unrefed ***\n");
exit (1);
}
else
{
printf ("ok\n# Testing completed\n1..1\n");
exit (0);
}
}
