/* Currently this is implemented using a timed out wait on our private DBus
* connection. Because the connection is private we don't have to worry about
* blocking other users. */
int VBoxMainHotplugWaiter::Wait(RTMSINTERVAL cMillies)
{
int rc = VINF_SUCCESS;
#if defined RT_OS_LINUX && defined VBOX_WITH_DBUS
if (!mContext->mConnection)
rc = VERR_NOT_SUPPORTED;
bool connected = true;
mContext->mTriggered = false;
mContext->mInterrupt = false;
unsigned cRealMillies;
if (cMillies != RT_INDEFINITE_WAIT)
cRealMillies = cMillies;
else
cRealMillies = DBUS_POLL_TIMEOUT;
while ( RT_SUCCESS(rc) && connected && !mContext->mTriggered
&& !mContext->mInterrupt)
{
connected = dbus_connection_read_write_dispatch (mContext->mConnection.get(),
cRealMillies);
if (mContext->mInterrupt)
LogFlowFunc(("wait loop interrupted\n"));
if (cMillies != RT_INDEFINITE_WAIT)
mContext->mInterrupt = true;
}
if (!connected)
rc = VERR_TRY_AGAIN;
#else /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
rc = VERR_NOT_IMPLEMENTED;
#endif /* !(defined RT_OS_LINUX && defined VBOX_WITH_DBUS) */
return rc;
}
void dbus_initialize(void) {
DBusError err;
dbus_threads_init_default();
dbus_error_init(&err);
if (!(service_bus = dbus_connection_open(SERVICE_BUS_ADDRESS, &err))) {
dbus_error_free(&err);
errx(1, "failed to connect to service bus: %s: %s", err.name, err.message);
}
if (!dbus_bus_register(service_bus, &err)) {
dbus_error_free(&err);
errx(1, "failed to register with service bus: %s: %s", err.name, err.message);
}
dbus_error_free(&err);
service_thread = std::thread([]() {
// dispatch messages until disconnect
while (dbus_connection_read_write_dispatch(service_bus, -1));
dbus_connection_unref(service_bus);
});
service_thread.detach();
}
int elektraDbusReceiveMessage (DBusBusType type, DBusHandleMessageFunction filter_func)
{
DBusConnection *connection;
DBusError error;
dbus_error_init (&error);
connection = dbus_bus_get (type, &error);
if (connection == NULL)
{
fprintf (stderr, "Failed to open connection to %s message bus: %s\n",
(type == DBUS_BUS_SYSTEM) ? "system" : "session",
error.message);
goto error;
}
dbus_bus_add_match (connection, "type='signal',interface='org.libelektra',path='/org/libelektra/configuration'", &error);
if (dbus_error_is_set (&error)) goto error;
if (!dbus_connection_add_filter (connection, filter_func, NULL, NULL))
{
goto error;
}
while (dbus_connection_read_write_dispatch(connection, -1));
return 0;
error:
printf ("Error occurred\n");
dbus_error_free (&error);
return -1;
}
int main(int argc, char *argv[])
{
DBusConnection *conn;
struct sigaction sa;
conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
if (!conn) {
fprintf(stderr, "Can't get on system bus");
return 1;
}
check_authorization(conn);
memset(&sa, 0, sizeof(sa));
sa.sa_flags = SA_NOCLDSTOP;
sa.sa_handler = sig_term;
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
#if 0
while (!__io_terminate) {
if (dbus_connection_read_write_dispatch(conn, 500) == FALSE)
break;
}
#endif
dbus_connection_unref(conn);
return 0;
}
static int ldbus_connection_read_write_dispatch(lua_State *L) {
DBusConnection *connection = check_DBusConnection(L, 1);
int timeout_milliseconds = luaL_optint(L, 2, -1);
lua_pushboolean(L, dbus_connection_read_write_dispatch(connection, timeout_milliseconds));
return 1;
}
gboolean
ibus_connection_read_write_dispatch (IBusConnection *connection,
gint timeout)
{
IBusConnectionPrivate *priv;
priv = IBUS_CONNECTION_GET_PRIVATE (connection);
return dbus_connection_read_write_dispatch (priv->connection, timeout);
}
static void *
_dbus_thread(void) {
manage_log(LOG_INFO, "_dbus_thread: PID %d\n", getpid());
while(manage_running
&& dbus_connection_read_write_dispatch(ac_manage_dbus_connection, 500)) {
}
return NULL;
}
static void Run ( intf_thread_t *p_intf )
{
for( ;; )
{
if( dbus_connection_get_dispatch_status(p_intf->p_sys->p_conn)
== DBUS_DISPATCH_COMPLETE )
msleep( INTF_IDLE_SLEEP );
int canc = vlc_savecancel();
dbus_connection_read_write_dispatch( p_intf->p_sys->p_conn, 0 );
/* Get the list of events to process
*
* We can't keep the lock on p_intf->p_sys->p_events, else we risk a
* deadlock:
* The signal functions could lock mutex X while p_events is locked;
* While some other function in vlc (playlist) might lock mutex X
* and then set a variable which would call AllCallback(), which itself
* needs to lock p_events to add a new event.
*/
vlc_mutex_lock( &p_intf->p_sys->lock );
int i_events = vlc_array_count( p_intf->p_sys->p_events );
callback_info_t* info[i_events];
for( int i = i_events - 1; i >= 0; i-- )
{
info[i] = vlc_array_item_at_index( p_intf->p_sys->p_events, i );
vlc_array_remove( p_intf->p_sys->p_events, i );
}
vlc_mutex_unlock( &p_intf->p_sys->lock );
for( int i = 0; i < i_events; i++ )
{
switch( info[i]->signal )
{
case SIGNAL_ITEM_CURRENT:
TrackChange( p_intf );
break;
case SIGNAL_INTF_CHANGE:
case SIGNAL_PLAYLIST_ITEM_APPEND:
case SIGNAL_PLAYLIST_ITEM_DELETED:
TrackListChangeEmit( p_intf, info[i]->signal, info[i]->i_node );
break;
case SIGNAL_RANDOM:
case SIGNAL_REPEAT:
case SIGNAL_LOOP:
StatusChangeEmit( p_intf );
break;
case SIGNAL_STATE:
StateChange( p_intf, info[i]->i_input_state );
break;
default:
assert(0);
}
free( info[i] );
}
vlc_restorecancel( canc );
}
}
int WaitUPowerStateChange() {
event = 0;
printf("[LPMTd] :: Waiting for power state change...\n");
while(dbus_connection_read_write_dispatch(conn, -1) && !event);
if(!event) {
return -1;
}
return upower_pstate;
}
int
main (int argc,
char **argv)
{
DBusError error;
DBusConnection *connection;
dbus_error_init (&error);
connection = dbus_bus_get (DBUS_BUS_STARTER, &error);
if (connection == NULL)
{
fprintf (stderr, "*** Failed to open connection to activating message bus: %s\n",
error.message);
dbus_error_free (&error);
return 1;
}
if (!dbus_connection_add_filter (connection,
filter_func, NULL, NULL))
die ("No memory");
if (!dbus_connection_register_object_path (connection,
echo_path,
&echo_vtable,
(void*) 0xdeadbeef))
die ("No memory");
{
void *d;
if (!dbus_connection_get_object_path_data (connection, echo_path, &d))
die ("No memory");
if (d != (void*) 0xdeadbeef)
die ("dbus_connection_get_object_path_data() doesn't seem to work right\n");
}
dbus_bus_request_name (connection, "org.freedesktop.DBus.GLib.TestEchoService",
0, &error);
if (dbus_error_is_set (&error))
{
fprintf (stderr, "Error %s\n", error.message);
dbus_error_free (&error);
exit (1);
}
while (dbus_connection_read_write_dispatch (connection, -1) && !already_quit)
;
dbus_connection_remove_filter (connection, filter_func, NULL);
dbus_connection_unref (connection);
dbus_shutdown ();
return 0;
}
void *bsd_dbus_thread_restart()
{
bsd_pid_write_v2("BSDDbus Reinit",HOST_SLOT_NO);
if(bsd_dbus_reinit()) {
while (dbus_connection_read_write_dispatch(bsd_dbus_connection,500)) {
}
}
bsd_syslog_err("there is something wrong in dbus handler\n");
return 0;
}
void *wbmd_dbus_thread_restart()
{
wbmd_pid_write_v2("WBMDDbus Reinit");
if(wbmd_dbus_reinit()
){
while (dbus_connection_read_write_dispatch(wbmd_dbus_connection,500)) {
}
}
wbmd_syslog_err("there is something wrong in dbus handler\n");
return 0;
}
void * igmp_snp_dbus_thread_main(void *arg)
{
int loop_count = 0;
/*
* For all OAM method call, synchronous is necessary.
* Only signal/event could be asynchronous, it could be sent in other thread.
*/
while (dbus_connection_read_write_dispatch(igmp_snp_dbus_connection,-1)) {
igmp_snp_syslog_dbg("igmp snooping dbus thread running.\n");
}
return NULL;
}
void initialize_dbus(void)
{
dbus_threads_init_default();
DBusError error;
dbus_error_init(&error);
// Initialize service bus
service_bus = dbus_connection_open(SERVICE_BUS_ADDRESS, &error);
if (!service_bus) {
errx(1, "failed to connect to service bus: %s: %s\n", error.name, error.message);
}
if (!dbus_bus_register(service_bus, &error)) {
errx(1, "failed to register with service bus: %s: %s\n", error.name, error.message);
}
// Initialize HMI bus
hmi_bus = dbus_connection_open(HMI_BUS_ADDRESS, &error);
if (!hmi_bus) {
errx(1, "failed to connect to HMI bus: %s: %s\n", error.name, error.message);
}
if (!dbus_bus_register(hmi_bus, &error)) {
errx(1, "failed to register with HMI bus: %s: %s\n", error.name, error.message);
}
std::thread service_thread([]() {
while (dbus_connection_read_write_dispatch(service_bus, -1));
});
std::thread hmi_thread([]() {
while (dbus_connection_read_write_dispatch(hmi_bus, -1));
});
service_thread.detach();
hmi_thread.detach();
}
static void
wakeup_handler(void *data, int err, void *read_mask)
{
struct dbus_core_info *info = data;
if (info->connection && FD_ISSET(info->fd, (fd_set *) read_mask)) {
do {
dbus_connection_read_write_dispatch(info->connection, 0);
} while (info->connection &&
dbus_connection_get_is_connected(info->connection) &&
dbus_connection_get_dispatch_status(info->connection) ==
DBUS_DISPATCH_DATA_REMAINS);
}
}
int main(int argc, char *argv[])
{
DBusError dberr;
DBusConnection *dbconn;
FILE *fp;
char *line, *idx;
size_t len=0;
ssize_t read;
int count=0;
fp = fopen("buttons_client.rc", "r");
if (NULL == fp) {
chdir(getenv("HOME"));
fp = fopen(".buttons_client.rc", "r");
if (NULL == fp) return -1;
}
while ((read = getline(&line, &len, fp)) != -1) {
if ((idx = strchr(line, '\r')) != NULL) *idx = '\0';
if ((idx = strchr(line, '\n')) != NULL) *idx = '\0';
if ((idx = strchr(line, ':')) != NULL) {
strncpy (buttons[count].button, line, (idx-line));
strcpy (buttons[count].command, idx+1);
}
count++;
}
fclose (fp);
dbus_error_init(&dberr);
dbconn = dbus_bus_get(DBUS_BUS_SESSION, &dberr);
if (dbus_error_is_set(&dberr)) {
dbus_error_free(&dberr);
return -1;
}
if (!dbus_connection_add_filter(dbconn, filter_func, NULL, NULL)) {
return -1;
}
dbus_bus_add_match(dbconn, "type='signal',interface='imobile.buttonsd.Type'", &dberr);
if (dbus_error_is_set(&dberr)) {
dbus_error_free(&dberr);
return -1;
}
while(dbus_connection_read_write_dispatch(dbconn, -1)) {
/* loop */
}
return 0;
}
void onDbusMessage(DBusConnection *conn)
{
if ( !m_bus )
return;
DBusMessage* msg;
DBusMessageIter args;
DBusError err;
int ret;
char* sigvalue;
// non blocking read of the next available message
dbus_connection_read_write_dispatch(conn, 0);
msg = dbus_connection_pop_message(conn);
// loop again if we haven't read a message
if (NULL == msg)
{
return;
}
//check if the message is a signal from the correct interface and with the correct name
if (dbus_message_is_signal (msg, "com.burtonini.dbus.Signal", "Ping"))
{
//read the parameters
if (!dbus_message_iter_init(msg, &args))
CRLog::error("dbus: Message Has No Parameters\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
CRLog::error("dbus: Argument is not string!\n");
else
{
dbus_message_iter_get_basic(&args, &sigvalue);
CRLog::info("dbus: Got Signal with value %s\n", sigvalue);
}
}
else if (dbus_message_is_signal (msg, "com.burtonini.dbus.Signal", "Exit"))
{
//read the parameters
if (!dbus_message_iter_init(msg, &args))
CRLog::error("dbus: Message Has No Parameters\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
CRLog::error("dbus: Argument is not string!\n");
else
{
dbus_message_iter_get_basic(&args, &sigvalue);
CRLog::info("dbus: Got Signal with value %s\n", sigvalue);
}
}
//free the message
dbus_message_unref(msg);
}
void pa_dbus_wrap_connection_free(pa_dbus_wrap_connection* c) {
pa_assert(c);
if (dbus_connection_get_is_connected(c->connection)) {
dbus_connection_close(c->connection);
/* must process remaining messages, bit of a kludge to handle
* both unload and shutdown */
while (dbus_connection_read_write_dispatch(c->connection, -1))
;
}
c->mainloop->defer_free(c->dispatch_event);
dbus_connection_unref(c->connection);
pa_xfree(c);
}
void Keyboard::Process()
{
while(!m_bStop && conn && dbus_connection_read_write_dispatch(conn, 0))
{
int ch[8];
int chnum = 0;
while ((ch[chnum] = getchar()) != EOF) chnum++;
if (chnum > 1) ch[0] = ch[chnum - 1] | (ch[chnum - 2] << 8);
if (m_keymap[ch[0]] != 0)
send_action(m_keymap[ch[0]]);
else
Sleep(20);
}
}
static DBusMessage *
send_and_allow_reentry (DBusConnection *bus, DBusMessage *message, DBusError *error)
{
DBusPendingCall *pending;
DBusMessage *reply = NULL;
if (!dbus_connection_send_with_reply (bus, message, &pending, -1))
{
return NULL;
}
dbus_pending_call_set_notify (pending, set_reply, (void *)&reply, NULL);
while (!reply)
{
if (!dbus_connection_read_write_dispatch (bus, -1))
return NULL;
}
return reply;
}
/**
* Description:
* WSM DBus thread function.
*
* Parameter:
* NULL
*
* Return:
* Void
*
*/
void wsm_dbus_main(void)
{
if (wsm_dbus_init())
{
WSMLog(L_CRIT, "%s: Initialize failed.\n", __func__);
exit(-1);
}
while (1)
{
if (!dbus_connection_read_write_dispatch(wsm_dbus_conn, DBUS_TIMEOUT))
{
break;
}
}
WSMLog(L_CRIT, "%s: Out of main loop, Critical ERROR.\n", __func__);
}
// Called from ProcessSlow to trigger the callbacks from DBus
bool CHALManager::Update()
{
CSingleLock lock(m_lock);
if (m_Context == NULL)
return false;
if (!dbus_connection_read_write_dispatch(m_DBusSystemConnection, 0)) // We choose 0 that means we won't wait for a message
{
CLog::Log(LOGERROR, "DBus: System - read/write dispatch");
return false;
}
if (NewMessage)
{
NewMessage = false;
return true;
}
else
return false;
}
int main (int argc, char *argv[])
{
DBusError dberr;
DBusConnection *dbconn;
dbus_error_init (&dberr);
dbconn = dbus_bus_get (DBUS_BUS_SESSION, &dberr);
if (dbus_error_is_set (&dberr)) {
fprintf (stderr, "getting session bus failed: %s\n", dberr.message);
dbus_error_free (&dberr);
return EXIT_FAILURE;
}
dbus_bus_request_name (dbconn, "com.wiley.test",
DBUS_NAME_FLAG_REPLACE_EXISTING, &dberr);
if (dbus_error_is_set (&dberr)) {
fprintf (stderr, "requesting name failed: %s\n", dberr.message);
dbus_error_free (&dberr);
return EXIT_FAILURE;
}
if (!dbus_connection_add_filter (dbconn, filter_func, NULL, NULL))
return EXIT_FAILURE;
dbus_bus_add_match (dbconn,
"type='signal',interface='com.wiley.test'",
&dberr);
if (dbus_error_is_set (&dberr)) {
fprintf (stderr, "Could not match: %s", dberr.message);
dbus_error_free (&dberr);
return EXIT_FAILURE;
}
while (dbus_connection_read_write_dispatch (dbconn, -1))
; /* empty loop body */
return EXIT_SUCCESS;
}
DBusMessage *
dbind_send_and_allow_reentry (DBusConnection * bus, DBusMessage * message, DBusError *error)
{
DBusPendingCall *pending;
SpiReentrantCallClosure *closure;
const char *unique_name = dbus_bus_get_unique_name (bus);
const char *destination = dbus_message_get_destination (message);
struct timeval tv;
DBusMessage *ret;
if (unique_name && destination &&
strcmp (destination, unique_name) != 0)
return dbus_connection_send_with_reply_and_block (bus, message, dbind_timeout, error);
closure = g_new0 (SpiReentrantCallClosure, 1);
closure->reply = NULL;
atspi_dbus_connection_setup_with_g_main(bus, NULL);
if (!dbus_connection_send_with_reply (bus, message, &pending, dbind_timeout))
return NULL;
if (!pending)
return NULL;
dbus_pending_call_set_notify (pending, set_reply, (void *) closure, g_free);
closure->reply = NULL;
gettimeofday (&tv, NULL);
dbus_pending_call_ref (pending);
while (!closure->reply)
{
if (!dbus_connection_read_write_dispatch (bus, dbind_timeout) ||
time_elapsed (&tv) > dbind_timeout)
{
dbus_pending_call_unref (pending);
return NULL;
}
}
ret = closure->reply;
dbus_pending_call_unref (pending);
return ret;
}
void Keyboard::Process()
{
while(!m_bStop)
{
CLog::Log(LOGDEBUG, "Keyboard: Process() m_bStop %d", m_bStop);
if (conn)
dbus_connection_read_write_dispatch(conn, 0);
int ch[8];
int chnum = 0;
while ((ch[chnum] = getchar()) != EOF) chnum++;
if (chnum > 1) ch[0] = ch[chnum - 1] | (ch[chnum - 2] << 8);
if (chnum > 0)
CLog::Log(LOGDEBUG, "Keyboard: character %c", ch[0]);
if (m_keymap[ch[0]] != 0)
send_action(m_keymap[ch[0]]);
else
Sleep(20);
}
}
MateKeyringResult
gkr_operation_block_and_unref (GkrOperation *op)
{
DBusPendingCall *pending;
g_return_val_if_fail (op, BROKEN);
while ((int) gkr_operation_get_result (op) == INCOMPLETE) {
if (op->pending) {
/*
* DBus has strange behavior that can complete a pending call
* in another thread and somehow does this without calling our
* on_pending_call_notify. So guard against this brokenness.
*/
pending = op->pending;
dbus_pending_call_block (pending);
if (op->pending == pending) {
g_return_val_if_fail (dbus_pending_call_get_completed (pending), BROKEN);
on_pending_call_notify (pending, op);
g_assert (op->pending != pending);
}
} else if (op->prompting) {
dbus_connection_flush (op->conn);
while (op->prompting && (int) gkr_operation_get_result (op) == INCOMPLETE) {
if (!dbus_connection_read_write_dispatch (op->conn, 200))
break;
}
} else {
g_assert_not_reached ();
}
}
/* Make sure we have run our callbacks if complete */
if (!g_queue_is_empty (&op->callbacks))
on_complete (op);
return gkr_operation_unref_get_result (op);
}
static int sync_auth(DBusConnection *bus, DBusError *error) {
usec_t begin, tstamp;
assert(bus);
/* This complexity should probably move into D-Bus itself:
*
* https://bugs.freedesktop.org/show_bug.cgi?id=35189 */
begin = tstamp = now(CLOCK_MONOTONIC);
for (;;) {
if (tstamp > begin + DEFAULT_TIMEOUT_USEC)
break;
if (dbus_connection_get_is_authenticated(bus))
break;
if (!dbus_connection_read_write_dispatch(bus, ((begin + DEFAULT_TIMEOUT_USEC - tstamp) + USEC_PER_MSEC - 1) / USEC_PER_MSEC))
break;
tstamp = now(CLOCK_MONOTONIC);
}
if (!dbus_connection_get_is_connected(bus)) {
dbus_set_error_const(error, DBUS_ERROR_NO_SERVER, "Connection terminated during authentication.");
return -ECONNREFUSED;
}
if (!dbus_connection_get_is_authenticated(bus)) {
dbus_set_error_const(error, DBUS_ERROR_TIMEOUT, "Failed to authenticate in time.");
return -EACCES;
}
return 0;
}
void OMXControl::dispatch()
{
if (bus)
dbus_connection_read_write_dispatch(bus, 0);
}
void*
serverthread(void*) {
DBusMessage* msg;
DBusError err;
int ret;
printf("Listening for method calls\n");
if (pipe(quitpipe) == -1) {
fprintf(stderr, "Could not create pipe.\n");
return 0;
}
// initialise the error
dbus_error_init(&err);
// connect to the bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
return 0;
}
if (NULL == conn) {
fprintf(stderr, "Connection Null\n");
return 0;
}
// request our name on the bus and check for errors
ret = dbus_bus_request_name(conn, "vandenoever.strigi",
DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Name Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
fprintf(stderr, "Not Primary Owner (%d)\n", ret);
return 0;
}
for (int i=0; i<10; ++i) {
printf("server\n");
}
int fd;
dbus_connection_get_unix_fd(conn, &fd);
bool run;
do {
// block until there's activit on the port
fd_set rfds;
struct timeval tv;
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
FD_SET(quitpipe[0], &rfds);
printf("server\n");
tv.tv_sec = 50000;
tv.tv_usec = 0;
int retval = select(fd+1, &rfds, 0, 0, &tv);
if (retval == -1 || FD_ISSET(quitpipe[0], &rfds)) break;
// non blocking read of the next available message
dbus_connection_read_write_dispatch(conn, 0);
// dbus_connection_read_write(conn, 0);
msg = dbus_connection_pop_message(conn);
dbus_connection_flush(conn);
dbus_message_unref(msg);
STRIGI_MUTEX_LOCK(&lock);
run = keeprunning;
STRIGI_MUTEX_UNLOCK(&lock);
} while (run);
dbus_connection_unref(conn);
dbus_connection_unref(conn);
dbus_shutdown();
printf("after dbus_shutdown\n");
return 0;
}
TEST_F(LibdbusTest, DISABLED_NonreplyingLibdbusConnectionsAreHandled) {
const char problemServiceName[] = "problem.service";
replyArrived = false;
bool running = true;
dbus_threads_init_default();
::DBusConnection* serviceConnection = createConnection();
::DBusConnection* clientConnection = createConnection();
dbus_bus_request_name(serviceConnection,
problemServiceName,
DBUS_NAME_FLAG_DO_NOT_QUEUE,
NULL);
dbus_connection_try_register_object_path(serviceConnection,
"/",
&libdbusObjectPathVTable,
NULL,
NULL);
std::thread([&, this] {
while(running) {
dbus_connection_read_write_dispatch(serviceConnection, 10);
}
}).detach();
usleep(100000);
::DBusMessage* message = dbus_message_new_method_call(problemServiceName, "/", NULL, "someMethod");
::DBusPendingCall* libdbusPendingCall;
dbus_connection_send_with_reply(
clientConnection,
message,
&libdbusPendingCall,
3000);
dbus_pending_call_set_notify(
libdbusPendingCall,
onLibdbusPendingCallNotifyThunk,
NULL,
NULL);
//100*50 = 5000 (ms) ==> 3 seconds timeout pending call *should* have arrived by now.
for (unsigned int i = 0; i < 100 && (!replyArrived); i++) {
dbus_connection_read_write_dispatch(clientConnection, 50);
}
EXPECT_TRUE(replyArrived);
running = false;
usleep(100000);
dbus_connection_close(serviceConnection);
dbus_connection_unref(serviceConnection);
dbus_connection_close(clientConnection);
dbus_connection_unref(clientConnection);
}
