static void setup (Fixture *f, gconstpointer data) { if (!dbus_threads_init_default ()) g_error ("OOM"); f->loop = _dbus_loop_new (); g_assert (f->loop != NULL); dbus_error_init (&f->e); f->server = dbus_server_listen ("tcp:host=127.0.0.1", &f->e); assert_no_error (&f->e); g_assert (f->server != NULL); if (!dbus_connection_allocate_data_slot (&connection_slot)) g_error ("OOM"); if (!dbus_server_allocate_data_slot (&server_slot)) g_error ("OOM"); if (!dbus_message_allocate_data_slot (&message_slot)) g_error ("OOM"); if (!dbus_pending_call_allocate_data_slot (&pending_call_slot)) g_error ("OOM"); }
/** * 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 setup (Fixture *f, gconstpointer data) { if (!dbus_threads_init_default ()) g_error ("OOM"); f->n_threads = N_THREADS; f->n_refs = N_REFS; // wine sets WINESERVERSOCKET for its child processes automatically if (g_getenv ("WINESERVERSOCKET") != NULL) { /* Our reference-counting is really slow under Wine (it involves * IPC to wineserver). Do fewer iterations: enough to demonstrate * that it works, rather than a performance test. */ f->n_threads = 10; f->n_refs = 10; } f->loop = _dbus_loop_new (); g_assert (f->loop != NULL); dbus_error_init (&f->e); f->server = dbus_server_listen ("tcp:host=127.0.0.1", &f->e); assert_no_error (&f->e); g_assert (f->server != NULL); if (!dbus_connection_allocate_data_slot (&connection_slot)) g_error ("OOM"); if (!dbus_server_allocate_data_slot (&server_slot)) g_error ("OOM"); if (!dbus_message_allocate_data_slot (&message_slot)) g_error ("OOM"); if (!dbus_pending_call_allocate_data_slot (&pending_call_slot)) g_error ("OOM"); }
/* 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); } }