static int
pcmk_dbus_watch_dispatch(gpointer userdata)
{
bool oom = FALSE;
DBusWatch *watch = userdata;
int flags = dbus_watch_get_flags(watch);
bool enabled = dbus_watch_get_enabled (watch);
mainloop_io_t *client = dbus_watch_get_data(watch);
crm_trace("Dispatching client %p: %s", client, dbus_watch_flags_to_string(flags));
if (enabled && is_set(flags, DBUS_WATCH_READABLE)) {
oom = !dbus_watch_handle(watch, flags);
} else if (enabled && is_set(flags, DBUS_WATCH_READABLE)) {
oom = !dbus_watch_handle(watch, flags);
} else if(enabled) {
oom = !dbus_watch_handle(watch, DBUS_WATCH_ERROR);
}
if(flags != dbus_watch_get_flags(watch)) {
flags = dbus_watch_get_flags(watch);
crm_trace("Dispatched client %p: %s (%d)", client, dbus_watch_flags_to_string(flags), flags);
}
if(oom) {
crm_err("DBus encountered OOM while attempting to dispatch %p (%s)", client, dbus_watch_flags_to_string(flags));
}
return 0;
}
static void MainLoop() {
struct ConnectionData* c = (struct ConnectionData*) FindTask(NULL)->tc_UserData;
kprintf("MainLoop started %08lx (cd %08lx)\n", FindTask(NULL), c);
c->signal = AllocSignal(-1);
if (c->signal == -1) {
goto exit;
}
Signal(c->creator, SIGF_SINGLE);
while(TRUE) {
ULONG signals = Wait(SIGBREAKF_CTRL_C | (1UL << c->signal));
kprintf("MainLoop got a signal %lx\n", signals);
if (signals & SIGBREAKF_CTRL_C) {
break;
}
if (signals & (1UL << c->signal)) {
struct WatchData* w;
// dbus_connection_ref(c->connection);
kprintf("Checking watches\n");
for(w = (struct WatchData*) c->watches.mlh_Head;
w->node.mln_Succ != NULL;
w = (struct WatchData*) w->node.mln_Succ) {
kprintf("%s watch on fd %ld, flags %lx\n",
w->enabled ? "Enabled" : "Disabled",
dbus_watch_get_fd(w->watch), dbus_watch_get_flags(w->watch));
if (w->enabled) {
dbus_watch_handle(w->watch, dbus_watch_get_flags(w->watch));
}
}
kprintf("Dispatching messages\n");
/* Dispatch messages */
while (dbus_connection_dispatch(c->connection) == DBUS_DISPATCH_DATA_REMAINS) {
kprintf("More messages available\n");
}
// dbus_connection_unref(c->connection);
}
}
exit:
c->main = NULL;
Signal(c->creator, SIGF_SINGLE);
kprintf("MainLoop terminating\n");
}
void set_dbus_listeners(int *maxfdp,
fd_set *rset, fd_set *wset, fd_set *eset)
{
struct watch *w;
for (w = daemon->watches; w; w = w->next)
if (dbus_watch_get_enabled(w->watch))
{
unsigned int flags = dbus_watch_get_flags(w->watch);
#if (DBUS_MINOR > 0)
int fd = dbus_watch_get_unix_fd(w->watch);
#else
int fd = dbus_watch_get_fd(w->watch);
#endif
bump_maxfd(fd, maxfdp);
if (flags & DBUS_WATCH_READABLE)
FD_SET(fd, rset);
if (flags & DBUS_WATCH_WRITABLE)
FD_SET(fd, wset);
FD_SET(fd, eset);
}
}
static dbus_bool_t addWatch(DBusWatch *watch, void *data)
{
dbus_bool_t result = FALSE;
(void)data;
if (ARRAY_SIZE(gPollInfo.fds) > (unsigned int)(gPollInfo.nfds))
{
unsigned int flags = dbus_watch_get_flags(watch);
tObjectEntry * const pEntry = &gPollInfo.objects[gPollInfo.nfds];
pEntry->objtype = OT_WATCH;
pEntry->watch = watch;
gPollInfo.fds[gPollInfo.nfds].fd = dbus_watch_get_unix_fd(watch);
if (TRUE==dbus_watch_get_enabled(watch))
{
if (flags&DBUS_WATCH_READABLE)
{
gPollInfo.fds[gPollInfo.nfds].events |= POLLIN;
}
if (flags&DBUS_WATCH_WRITABLE)
{
gPollInfo.fds[gPollInfo.nfds].events |= POLLOUT;
}
++gPollInfo.nfds;
}
result = TRUE;
}
return result;
}
static void edbus_remove_watch(DBusWatch* watch, void* d) {
E_ASSERT(watch != NULL);
EdbusConnImpl* dc = (EdbusConnImpl*)d;
E_ASSERT(dc != NULL);
E_ASSERT(dc->watch_list != NULL);
/* E_DEBUG(E_STRLOC ": removing watch\n"); */
int fd = dbus_watch_get_fd(watch);
int flags = dbus_watch_get_flags(watch);
if(flags & DBUS_WATCH_READABLE)
Fl::remove_fd(fd, FL_READ);
if(flags & DBUS_WATCH_WRITABLE)
Fl::remove_fd(fd, FL_WRITE);
WatchListIter it = dc->watch_list->begin(), it_end = dc->watch_list->end();
while(it != it_end) {
if(*it == watch) {
dc->watch_list->erase(it);
break;
}
++it;
}
}
static dbus_bool_t edbus_add_watch(DBusWatch* watch, void* d) {
E_ASSERT(watch != NULL);
/*
* check if watch is enabled since dbus_watch_handle() can't be used
* on as connection will not be ready to handle this watch yet
*/
if(!dbus_watch_get_enabled(watch))
return 1;
EdbusConnImpl* dc = (EdbusConnImpl*)d;
E_ASSERT(dc != NULL);
E_ASSERT(dc->watch_list != NULL);
int fd = dbus_watch_get_fd(watch);
int flags = dbus_watch_get_flags(watch);
dc->watch_list->push_back(watch);
if(flags & DBUS_WATCH_READABLE)
Fl::add_fd(fd, FL_READ, read_watch_cb, d);
if(flags & DBUS_WATCH_WRITABLE)
Fl::add_fd(fd, FL_WRITE, write_watch_cb, d);
return 1;
}
void
DBusWatcher::RemoveWatch(DBusWatch* aWatch)
{
static const char control = DBUS_EVENT_LOOP_REMOVE;
ssize_t res =
TEMP_FAILURE_RETRY(write(mControlFdW.get(), &control, sizeof(control)));
if (res < 0) {
LOG("Cannot write DBus remove watch control data to socket!\n");
return;
}
int fd = dbus_watch_get_unix_fd(aWatch);
res = TEMP_FAILURE_RETRY(write(mControlFdW.get(), &fd, sizeof(fd)));
if (res < 0) {
LOG("Cannot write DBus remove watch descriptor data to socket!\n");
return;
}
unsigned int flags = dbus_watch_get_flags(aWatch);
res = TEMP_FAILURE_RETRY(write(mControlFdW.get(), &flags, sizeof(flags)));
if (res < 0) {
LOG("Cannot write DBus remove watch flag data to socket!\n");
return;
}
}
static dbus_bool_t
AddWatch(DBusWatch *aWatch, void *aData)
{
DBusThread *dbt = (DBusThread *)aData;
if (dbus_watch_get_enabled(aWatch)) {
// note that we can't just send the watch and inspect it later
// because we may get a removeWatch call before this data is reacted
// to by our eventloop and remove this watch.. reading the add first
// and then inspecting the recently deceased watch would be bad.
char control = DBUS_EVENT_LOOP_ADD;
if (write(dbt->mControlFdW.get(), &control, sizeof(char)) < 0) {
LOG("Cannot write DBus add watch control data to socket!\n");
return false;
}
int fd = dbus_watch_get_unix_fd(aWatch);
if (write(dbt->mControlFdW.get(), &fd, sizeof(int)) < 0) {
LOG("Cannot write DBus add watch descriptor data to socket!\n");
return false;
}
unsigned int flags = dbus_watch_get_flags(aWatch);
if (write(dbt->mControlFdW.get(), &flags, sizeof(unsigned int)) < 0) {
LOG("Cannot write DBus add watch flag data to socket!\n");
return false;
}
if (write(dbt->mControlFdW.get(), &aWatch, sizeof(DBusWatch*)) < 0) {
LOG("Cannot write DBus add watch struct data to socket!\n");
return false;
}
}
return true;
}
static int get_pollfds(struct dbus* dbus, struct pollfd *pollfds)
{
int count = 0;
Word_t index = 0;
DBusWatch** pwatch;
JLF(pwatch, dbus->watches, index);
while(pwatch != NULL) {
DBusWatch* watch = *pwatch;
if(dbus_watch_get_enabled(watch)) {
pollfds[count].fd = dbus_watch_get_unix_fd(watch);
pollfds[count].events = 0;
int flags = dbus_watch_get_flags(watch);
if(flags & DBUS_WATCH_READABLE) pollfds[count].events |= POLLIN | POLLPRI;
if(flags & DBUS_WATCH_WRITABLE) pollfds[count].events |= POLLOUT;
count += 1;
}
JLN(pwatch, dbus->watches, index);
}
return count;
}
static dbus_bool_t
add(DBusWatch *watch, void *data)
{
JoyDBus *self = JOY_DBUS(data);
if (G_UNLIKELY(!self)) {
goto exit;
}
struct Private *priv = GET_PRIVATE(self);
if (G_UNLIKELY(!priv->app)) {
goto exit;
}
if (!dbus_watch_get_enabled(watch)) {
goto exit;
}
JoySource *source = joy_source_dbus_new(self, watch);
if (G_UNLIKELY(!source)) {
goto exit;
}
g_object_ref_sink(source);
g_hash_table_insert(priv->sources, watch, source);
guint condition = dbus_watch_get_flags(watch);
if (condition & DBUS_WATCH_READABLE) {
joy_source_set_condition(source, G_IO_IN);
}
if (condition & DBUS_WATCH_WRITABLE) {
joy_source_set_condition(source, G_IO_OUT);
}
joy_application_add_source(priv->app, source);
exit:
return TRUE;
}
static dbus_bool_t add_watch(DBusWatch *watch, void *data)
{
DBusConnection *conn = data;
GIOCondition cond = G_IO_HUP | G_IO_ERR;
GIOChannel *chan;
struct watch_info *info;
unsigned int flags;
int fd;
if (!dbus_watch_get_enabled(watch))
return TRUE;
info = g_new0(struct watch_info, 1);
fd = dbus_watch_get_unix_fd(watch);
chan = g_io_channel_unix_new(fd);
info->watch = watch;
info->conn = dbus_connection_ref(conn);
dbus_watch_set_data(watch, info, watch_info_free);
flags = dbus_watch_get_flags(watch);
if (flags & DBUS_WATCH_READABLE) cond |= G_IO_IN;
if (flags & DBUS_WATCH_WRITABLE) cond |= G_IO_OUT;
info->id = g_io_add_watch(chan, cond, watch_func, info);
g_io_channel_unref(chan);
return TRUE;
}
/**
* GetPollFds() fills an array of pollfd data structures with :
* - the set of enabled dbus watches
* - the unix pipe which we use to manually wake up the main loop
*
* This function must be called with p_sys->lock locked
*
* @return The number of file descriptors
*
* @param intf_thread_t *p_intf this interface thread's state
* @param struct pollfd *p_fds a pointer to a pollfd array large enough to
* contain all the returned data (number of enabled dbus watches + 1)
*/
static int GetPollFds( intf_thread_t *p_intf, struct pollfd *p_fds )
{
intf_sys_t *p_sys = p_intf->p_sys;
int i_fds = 1, i_watches = vlc_array_count( p_sys->p_watches );
p_fds[0].fd = p_sys->p_pipe_fds[PIPE_OUT];
p_fds[0].events = POLLIN | POLLPRI;
for( int i = 0; i < i_watches; i++ )
{
DBusWatch *p_watch = NULL;
p_watch = vlc_array_item_at_index( p_sys->p_watches, i );
if( !dbus_watch_get_enabled( p_watch ) )
continue;
p_fds[i_fds].fd = dbus_watch_get_unix_fd( p_watch );
int i_flags = dbus_watch_get_flags( p_watch );
if( i_flags & DBUS_WATCH_READABLE )
p_fds[i_fds].events |= POLLIN | POLLPRI;
if( i_flags & DBUS_WATCH_WRITABLE )
p_fds[i_fds].events |= POLLOUT;
i_fds++;
}
return i_fds;
}
static dbus_bool_t add_watch(DBusWatch *watch, void *data)
{
struct wpas_dbus_priv *priv = data;
unsigned int flags;
int fd;
if (!dbus_watch_get_enabled(watch))
return TRUE;
flags = dbus_watch_get_flags(watch);
fd = dbus_watch_get_unix_fd(watch);
eloop_register_sock(fd, EVENT_TYPE_EXCEPTION, process_watch_exception,
priv, watch);
if (flags & DBUS_WATCH_READABLE) {
eloop_register_sock(fd, EVENT_TYPE_READ, process_watch_read,
priv, watch);
}
if (flags & DBUS_WATCH_WRITABLE) {
eloop_register_sock(fd, EVENT_TYPE_WRITE, process_watch_write,
priv, watch);
}
dbus_watch_set_data(watch, priv, NULL);
return TRUE;
}
static dbus_bool_t add_watch(DBusWatch *watch, void *data)
{
GIOCondition cond = G_IO_HUP | G_IO_ERR;
DBusConnection *conn = data;
struct watch_info *info;
int fd, flags;
if (!dbus_watch_get_enabled(watch))
return TRUE;
info = g_new(struct watch_info, 1);
fd = dbus_watch_get_unix_fd(watch);
info->io = g_io_channel_unix_new(fd);
info->conn = dbus_connection_ref(conn);
dbus_watch_set_data(watch, info, NULL);
flags = dbus_watch_get_flags(watch);
if (flags & DBUS_WATCH_READABLE) cond |= G_IO_IN;
if (flags & DBUS_WATCH_WRITABLE) cond |= G_IO_OUT;
info->watch_id = g_io_add_watch(info->io, cond, watch_func, watch);
return TRUE;
}
static dbus_bool_t virDBusAddWatch(DBusWatch *watch,
void *data)
{
int flags = 0;
int fd;
struct virDBusWatch *info;
if (VIR_ALLOC(info) < 0)
return 0;
if (dbus_watch_get_enabled(watch))
flags = virDBusTranslateWatchFlags(dbus_watch_get_flags(watch));
# if HAVE_DBUS_WATCH_GET_UNIX_FD
fd = dbus_watch_get_unix_fd(watch);
# else
fd = dbus_watch_get_fd(watch);
# endif
info->bus = (DBusConnection *)data;
info->watch = virEventAddHandle(fd, flags,
virDBusWatchCallback,
watch, NULL);
if (info->watch < 0) {
VIR_FREE(info);
return 0;
}
dbus_watch_set_data(watch, info, virDBusWatchFree);
return 1;
}
//Callbacks implementation
unsigned int DBusHandler::Callbacks::addWatch(DBusWatch* watch, void* data)
{
if(!data) return 0;
auto& loop = static_cast<DBusHandler*>(data)->compositor().wlEventLoop();
unsigned int mask = 0;
if (dbus_watch_get_enabled(watch))
{
unsigned int flags = dbus_watch_get_flags(watch);
if (flags & DBUS_WATCH_READABLE) mask |= WL_EVENT_READABLE;
if (flags & DBUS_WATCH_WRITABLE) mask |= WL_EVENT_WRITABLE;
}
int fd = dbus_watch_get_unix_fd(watch);
wl_event_source* source = wl_event_loop_add_fd(&loop, fd, mask, dispatchWatch, watch);
if (!source)
{
ny::sendWarning("failed to add dbus watch wl_event_loop_fd");
return 0;
}
dbus_watch_set_data(watch, source, nullptr);
return 1;
}
/* Callback: "dbus_watch_get_enabled() may return a different value than it did before" */
static void toggled_watch(DBusWatch *watch, void* data)
{
log_debug("%s(watch:%p, data)", __func__, watch);
watch_app_info_t* app_info = (watch_app_info_t*)dbus_watch_get_data(watch);
if (dbus_watch_get_enabled(watch))
{
if (!app_info->watch_enabled)
{
app_info->watch_enabled = true;
int dbus_flags = dbus_watch_get_flags(watch);
int glib_flags = 0;
if (dbus_flags & DBUS_WATCH_READABLE) glib_flags |= G_IO_IN;
if (dbus_flags & DBUS_WATCH_WRITABLE) glib_flags |= G_IO_OUT;
log_debug(" adding watch to glib main loop. dbus_flags:%x glib_flags:%x", dbus_flags, glib_flags);
app_info->event_source_id = g_io_add_watch(app_info->channel, (GIOCondition)glib_flags, handle_dbus_fd, watch);
}
/* else: it was already enabled */
}
else
{
if (app_info->watch_enabled)
{
app_info->watch_enabled = false;
/* does it free the hidden GSource too? */
log_debug(" removing watch from glib main loop");
g_source_remove(app_info->event_source_id);
}
/* else: it was already disabled */
}
}
static void connection_setup_add_watch(struct ctrl_iface_dbus_priv *iface,
DBusWatch *watch)
{
unsigned int flags;
int fd;
if (!dbus_watch_get_enabled(watch))
return;
flags = dbus_watch_get_flags(watch);
fd = dbus_watch_get_unix_fd(watch);
eloop_register_sock(fd, EVENT_TYPE_EXCEPTION, process_watch_exception,
iface, watch);
if (flags & DBUS_WATCH_READABLE) {
eloop_register_sock(fd, EVENT_TYPE_READ, process_watch_read,
iface, watch);
}
if (flags & DBUS_WATCH_WRITABLE) {
eloop_register_sock(fd, EVENT_TYPE_WRITE, process_watch_write,
iface, watch);
}
dbus_watch_set_data(watch, iface, NULL);
}
static dbus_bool_t add_watch(DBusWatch *w, void *data)
{
if (!dbus_watch_get_enabled(w))
return TRUE;
ASDBusFd *fd = safecalloc (1, sizeof(ASDBusFd));
fd->fd = dbus_watch_get_unix_fd(w);
unsigned int flags = dbus_watch_get_flags(w);
if (get_flags(flags, DBUS_WATCH_READABLE))
fd->readable = True;
/*short cond = EV_PERSIST;
if (flags & DBUS_WATCH_READABLE)
cond |= EV_READ;
if (flags & DBUS_WATCH_WRITABLE)
cond |= EV_WRITE; */
// TODO add to the list of FDs
dbus_watch_set_data(w, fd, NULL);
if (ASDBus.watchFds == NULL)
ASDBus.watchFds = create_asvector (sizeof(ASDBusFd*));
append_vector(ASDBus.watchFds, &fd, 1);
show_debug(__FILE__,__FUNCTION__,__LINE__,"added dbus watch fd=%d watch=%p readable =%d\n", fd->fd, w, fd->readable);
return TRUE;
}
static dbus_bool_t add_watch( DBusWatch *p_watch, void *p_data )
{
intf_thread_t *p_intf = (intf_thread_t*) p_data;
intf_sys_t *p_sys = (intf_sys_t*) p_intf->p_sys;
int i_fd = dbus_watch_get_unix_fd( p_watch );
msg_Dbg( p_intf, "Adding dbus watch on fd %d", i_fd );
if( dbus_watch_get_flags( p_watch ) & DBUS_WATCH_READABLE )
msg_Dbg( p_intf, "Watching fd %d for readability", i_fd );
if( dbus_watch_get_flags( p_watch ) & DBUS_WATCH_WRITABLE )
msg_Dbg( p_intf, "Watching fd %d for writeability", i_fd );
vlc_mutex_lock( &p_sys->lock );
vlc_array_append( p_sys->p_watches, p_watch );
vlc_mutex_unlock( &p_sys->lock );
return TRUE;
}
static short
vlc_dbus_watch_get_poll_events( DBusWatch *p_watch )
{
unsigned int i_flags = dbus_watch_get_flags( p_watch );
short i_events = 0;
if( i_flags & DBUS_WATCH_READABLE )
i_events |= POLLIN;
if( i_flags & DBUS_WATCH_WRITABLE )
i_events |= POLLOUT;
return i_events;
}
static dbus_bool_t update_watch(const AvahiPoll *poll_api, DBusWatch *dbus_watch) {
AvahiWatch *avahi_watch;
dbus_bool_t b;
assert(dbus_watch);
avahi_watch = dbus_watch_get_data(dbus_watch);
b = dbus_watch_get_enabled(dbus_watch);
if (b && !avahi_watch) {
if (!(avahi_watch = poll_api->watch_new(
poll_api,
#if (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR == 1 && DBUS_VERSION_MICRO >= 1) || (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR > 1) || (DBUS_VERSION_MAJOR > 1)
dbus_watch_get_unix_fd(dbus_watch),
#else
dbus_watch_get_fd(dbus_watch),
#endif
translate_dbus_to_avahi(dbus_watch_get_flags(dbus_watch)),
watch_callback,
dbus_watch)))
return FALSE;
dbus_watch_set_data(dbus_watch, avahi_watch, NULL);
} else if (!b && avahi_watch) {
poll_api->watch_free(avahi_watch);
dbus_watch_set_data(dbus_watch, NULL, NULL);
} else if (avahi_watch) {
/* Update flags */
poll_api->watch_update(avahi_watch, dbus_watch_get_flags(dbus_watch));
}
return TRUE;
}
static dbus_bool_t
watch_add(DBusWatch *watch, void *data)
{
struct watch *w;
lem_debug("watch = %p, fd = %d, flags = %s, enabled = %s",
(void *)watch,
dbus_watch_get_unix_fd(watch),
dbus_watch_get_flags(watch) & DBUS_WATCH_READABLE ? "READ" : "WRITE",
dbus_watch_get_enabled(watch) ? "true" : "false");
w = lem_xmalloc(sizeof(struct watch));
ev_io_init(&w->ev, watch_handler, dbus_watch_get_unix_fd(watch),
flags_to_revents(dbus_watch_get_flags(watch)));
w->conn = data;
w->watch = watch;
dbus_watch_set_data(watch, w, NULL);
if (dbus_watch_get_enabled(watch))
ev_io_start(EV_G_ &w->ev);
return TRUE;
}
static void
watch_toggle(DBusWatch *watch, void *data)
{
struct watch *w;
(void)data;
lem_debug("watch = %p, fd = %d, flags = %s, enabled = %s",
(void *)watch,
dbus_watch_get_unix_fd(watch),
dbus_watch_get_flags(watch) & DBUS_WATCH_READABLE ? "READ" : "WRITE",
dbus_watch_get_enabled(watch) ? "true" : "false");
w = dbus_watch_get_data(watch);
if (dbus_watch_get_enabled(watch)) {
if (ev_is_active(&w->ev))
ev_io_stop(EV_G_ &w->ev);
ev_io_set(EV_G_ &w->ev, w->ev.fd,
flags_to_revents(dbus_watch_get_flags(watch)));
ev_io_start(EV_G_ &w->ev);
} else
ev_io_stop(EV_G_ &w->ev);
}
void Integrator::addWatch( DBusWatch *watch )
{
if ( !dbus_watch_get_enabled( watch ) )
return;
Watch *qtwatch = new Watch;
qtwatch->watch = watch;
int flags = dbus_watch_get_flags( watch );
int fd = dbus_watch_get_fd( watch );
if ( flags & DBUS_WATCH_READABLE ) {
qtwatch->readSocket = new QSocketNotifier( fd, QSocketNotifier::Read, this );
QObject::connect( qtwatch->readSocket, SIGNAL(activated(int)), SLOT(slotRead(int)) );
}
static void remove_watch(DBusWatch *watch, void *data)
{
unsigned int flags;
int fd;
flags = dbus_watch_get_flags(watch);
fd = dbus_watch_get_unix_fd(watch);
eloop_unregister_sock(fd, EVENT_TYPE_EXCEPTION);
if (flags & DBUS_WATCH_READABLE)
eloop_unregister_sock(fd, EVENT_TYPE_READ);
if (flags & DBUS_WATCH_WRITABLE)
eloop_unregister_sock(fd, EVENT_TYPE_WRITE);
dbus_watch_set_data(watch, NULL, NULL);
}
static void
watch_remove(DBusWatch *watch, void *data)
{
struct watch *w;
(void)data;
lem_debug("watch = %p, fd = %d, flags = %s, enabled = %s",
(void *)watch,
dbus_watch_get_unix_fd(watch),
dbus_watch_get_flags(watch) & DBUS_WATCH_READABLE ? "READ" : "WRITE",
dbus_watch_get_enabled(watch) ? "true" : "false");
w = dbus_watch_get_data(watch);
ev_io_stop(EV_G_ &w->ev);
free(w);
}
static dbus_bool_t add_watch(DBusWatch *watch, void *data)
{
short cond = POLLHUP | POLLERR;
int fd = dbus_watch_get_unix_fd(watch);
unsigned int flags = dbus_watch_get_flags(watch);
if (flags & DBUS_WATCH_READABLE)
cond |= POLLIN;
if (flags & DBUS_WATCH_WRITABLE)
cond |= POLLOUT;
bus_fds[bus_nr_watches].fd = fd;
bus_fds[bus_nr_watches].events = cond;
bus_watches[bus_nr_watches] = watch;
bus_nr_watches++;
return 1;
}
static void connection_setup_remove_watch(struct ctrl_iface_dbus_priv *iface,
DBusWatch *watch)
{
unsigned int flags;
int fd;
flags = dbus_watch_get_flags(watch);
fd = dbus_watch_get_unix_fd(watch);
eloop_unregister_sock(fd, EVENT_TYPE_EXCEPTION);
if (flags & DBUS_WATCH_READABLE)
eloop_unregister_sock(fd, EVENT_TYPE_READ);
if (flags & DBUS_WATCH_WRITABLE)
eloop_unregister_sock(fd, EVENT_TYPE_WRITE);
dbus_watch_set_data(watch, NULL, NULL);
}
static pa_io_event_flags_t get_watch_flags(DBusWatch *watch) {
unsigned int flags;
pa_io_event_flags_t events = 0;
pa_assert(watch);
flags = dbus_watch_get_flags(watch);
/* no watch flags for disabled watches */
if (!dbus_watch_get_enabled(watch))
return PA_IO_EVENT_NULL;
if (flags & DBUS_WATCH_READABLE)
events |= PA_IO_EVENT_INPUT;
if (flags & DBUS_WATCH_WRITABLE)
events |= PA_IO_EVENT_OUTPUT;
return events | PA_IO_EVENT_HANGUP | PA_IO_EVENT_ERROR;
}
