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; }