static void
connection_setup_remove_watch (ConnectionSetup *cs, DBusWatch *watch)
{
IOHandler *handler = dbus_watch_get_data (watch);
if (handler != NULL)
io_handler_destroy_source (handler);
}
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;
}
/* 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
pcmk_dbus_watch_remove(DBusWatch *watch, void *data){
mainloop_io_t *client = dbus_watch_get_data(watch);
crm_trace("Removed client %p (%p)", client, data);
mainloop_del_fd(client);
}
static void remove_watch(DBusWatch *w, void *data)
{
ASDBusFd* fd = dbus_watch_get_data(w);
vector_remove_elem (ASDBus.watchFds, &fd);
dbus_watch_set_data(w, NULL, NULL);
show_debug(__FILE__,__FUNCTION__,__LINE__,"removed dbus watch watch=%p\n", w);
}
void
DBusWatcher::RemoveWatchFunction(DBusWatch* aWatch, void* aData)
{
MOZ_ASSERT(!NS_IsMainThread());
DBusWatcher* dbusWatcher =
static_cast<DBusWatcher*>(dbus_watch_get_data(aWatch));
dbusWatcher->StopWatching();
}
static void WatchToggledFunction(DBusWatch* watch,
void* data) {
struct ConnectionData* c = (struct ConnectionData*) data;
struct WatchData* w = (struct WatchData*) dbus_watch_get_data(watch);
kprintf("WatchToggledFunction %lx\n", w);
w->enabled = dbus_watch_get_enabled(watch);
}
static void remove_watch(DBusWatch *watch, void *data)
{
guint id = (guint) dbus_watch_get_data(watch);
dbus_watch_set_data(watch, NULL, NULL);
if (id)
g_io_remove_watch(id);
}
/* DBusRemoveWatchFunction callback for pa mainloop */
static void remove_watch(DBusWatch *watch, void *data) {
pa_dbus_wrap_connection *c = data;
pa_io_event *ev;
pa_assert(watch);
pa_assert(c);
if ((ev = dbus_watch_get_data(watch)))
c->mainloop->io_free(ev);
}
static void weston_dbus_remove_watch(DBusWatch *watch, void *data)
{
struct wl_event_source *s;
s = dbus_watch_get_data(watch);
if (!s)
return;
wl_event_source_remove(s);
}
static void RemoveWatchFunction(DBusWatch* watch,
void* data) {
struct ConnectionData* c = (struct ConnectionData*) data;
struct WatchData* w = (struct WatchData*) dbus_watch_get_data(watch);
kprintf("RemoveWatchFunction %lx\n", w);
dbus_watch_set_data(watch, NULL, NULL);
DeleteWatchData(w);
}
/* Callback: "libdbus no longer needs a watch to be monitored by the main loop" */
static void remove_watch(DBusWatch *watch, void* data)
{
log_debug("%s()", __func__);
watch_app_info_t* app_info = (watch_app_info_t*)dbus_watch_get_data(watch);
if (app_info->watch_enabled)
{
app_info->watch_enabled = false;
g_source_remove(app_info->event_source_id);
}
g_io_channel_unref(app_info->channel);
}
void DBusHandler::Callbacks::removeWatch(DBusWatch* watch, void* data)
{
wl_event_source* s = nullptr;
if (!(s = (wl_event_source*) dbus_watch_get_data(watch)))
{
ny::sendWarning("dbusRemoveWatch: dbus watch has no data");
return;
}
wl_event_source_remove(s);
}
/* DBusWatchToggledFunction callback for pa mainloop */
static void toggle_watch(DBusWatch *watch, void *data) {
pa_dbus_wrap_connection *c = data;
pa_io_event *ev;
pa_assert(watch);
pa_assert(c);
pa_assert_se(ev = dbus_watch_get_data(watch));
/* get_watch_flags() checks if the watch is enabled */
c->mainloop->io_enable(ev, get_watch_flags(watch));
}
static void remove_watch(DBusWatch *dbus_watch, void *userdata) {
ConnectionData *d = userdata;
AvahiWatch *avahi_watch;
assert(dbus_watch);
assert(d);
if ((avahi_watch = dbus_watch_get_data(dbus_watch))) {
d->poll_api->watch_free(avahi_watch);
dbus_watch_set_data(dbus_watch, NULL, NULL);
}
}
static void remove_watch(DBusWatch *watch, void *data)
{
struct watch_info *info = dbus_watch_get_data(watch);
dbus_watch_set_data(watch, NULL, NULL);
if (info) {
g_source_remove(info->watch_id);
g_io_channel_unref(info->io);
dbus_connection_unref(info->conn);
g_free(info);
}
}
static void removeWatch(DBusWatch *watch, void *data)
{
void* w_data = dbus_watch_get_data(watch);
(void)data;
DLT_LOG(gPclDLTContext, DLT_LOG_INFO, DLT_STRING("removeWatch called "), DLT_INT64( (long)watch) );
if(w_data)
free(w_data);
dbus_watch_set_data(watch, NULL, NULL);
}
void
DBusWatcher::ToggleWatchFunction(DBusWatch* aWatch, void* aData)
{
MOZ_ASSERT(!NS_IsMainThread());
DBusWatcher* dbusWatcher =
static_cast<DBusWatcher*>(dbus_watch_get_data(aWatch));
if (dbus_watch_get_enabled(aWatch)) {
dbusWatcher->StartWatching();
} else {
dbusWatcher->StopWatching();
}
}
static void remove_watch(DBusWatch *watch, void *data) {
EpollData _cleanup_free_ *e = NULL;
assert(watch);
e = dbus_watch_get_data(watch);
if (!e)
return;
assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_DEL, e->fd, NULL) >= 0);
if (e->fd_is_dupped)
close_nointr_nofail(e->fd);
}
static void toggle_watch(DBusWatch *watch, void *data) {
EpollData *e;
struct epoll_event ev;
assert(watch);
e = dbus_watch_get_data(watch);
if (!e)
return;
zero(ev);
ev.events = bus_flags_to_events(watch);
ev.data.ptr = e;
assert_se(epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_MOD, e->fd, &ev) == 0);
}
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 gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data)
{
DBusWatch *watch = data;
struct watch_info *info = dbus_watch_get_data(watch);
int flags = 0;
if (cond & G_IO_IN) flags |= DBUS_WATCH_READABLE;
if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE;
if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP;
if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR;
dbus_watch_handle(watch, flags);
if (dbus_connection_get_dispatch_status(info->conn) == DBUS_DISPATCH_DATA_REMAINS)
g_timeout_add(DISPATCH_TIMEOUT, message_dispatch_cb, info->conn);
return TRUE;
}
static void weston_dbus_toggle_watch(DBusWatch *watch, void *data)
{
struct wl_event_source *s;
uint32_t mask = 0, flags;
s = dbus_watch_get_data(watch);
if (!s)
return;
if (dbus_watch_get_enabled(watch)) {
flags = dbus_watch_get_flags(watch);
if (flags & DBUS_WATCH_READABLE)
mask |= WL_EVENT_READABLE;
if (flags & DBUS_WATCH_WRITABLE)
mask |= WL_EVENT_WRITABLE;
}
wl_event_source_fd_update(s, mask);
}
void DBusHandler::Callbacks::toggleWatch(DBusWatch* watch, void* data)
{
struct wl_event_source *s;
if(!(s = (wl_event_source*) dbus_watch_get_data(watch)))
{
ny::sendWarning("dbusToggleWatch: dbus watch has no data");
return;
}
uint32_t 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;
}
wl_event_source_fd_update(s, mask);
}
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 void
connection_setup_add_watch (ConnectionSetup *cs,
DBusWatch *watch)
{
guint flags;
GIOCondition condition;
GIOChannel *channel;
IOHandler *handler;
if (!dbus_watch_get_enabled (watch))
return;
g_assert (dbus_watch_get_data (watch) == NULL);
flags = dbus_watch_get_flags (watch);
condition = G_IO_ERR | G_IO_HUP;
if (flags & DBUS_WATCH_READABLE)
condition |= G_IO_IN;
if (flags & DBUS_WATCH_WRITABLE)
condition |= G_IO_OUT;
handler = g_slice_new (IOHandler);
handler->cs = cs;
handler->watch = watch;
channel = g_io_channel_unix_new (dbus_watch_get_unix_fd (watch));
handler->source = g_io_create_watch (channel, condition);
g_source_set_callback (handler->source, (GSourceFunc) io_handler_dispatch, handler,
io_handler_source_finalized);
g_source_attach (handler->source, cs->context);
cs->ios = g_slist_prepend (cs->ios, handler);
dbus_watch_set_data (watch, handler, io_handler_watch_freed);
g_io_channel_unref (channel);
}
static void virDBusWatchCallback(int fdatch ATTRIBUTE_UNUSED,
int fd ATTRIBUTE_UNUSED,
int events, void *opaque)
{
DBusWatch *watch = opaque;
struct virDBusWatch *info;
int dbus_flags = 0;
info = dbus_watch_get_data(watch);
if (events & VIR_EVENT_HANDLE_READABLE)
dbus_flags |= DBUS_WATCH_READABLE;
if (events & VIR_EVENT_HANDLE_WRITABLE)
dbus_flags |= DBUS_WATCH_WRITABLE;
if (events & VIR_EVENT_HANDLE_ERROR)
dbus_flags |= DBUS_WATCH_ERROR;
if (events & VIR_EVENT_HANDLE_HANGUP)
dbus_flags |= DBUS_WATCH_HANGUP;
(void)dbus_watch_handle(watch, dbus_flags);
while (dbus_connection_dispatch(info->bus) == DBUS_DISPATCH_DATA_REMAINS)
/* keep dispatching while data remains */;
}
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);
}
static void
pcmk_dbus_watch_toggle(DBusWatch *watch, void *data)
{
mainloop_io_t *client = dbus_watch_get_data(watch);
crm_notice("DBus client %p is now %s", client, dbus_watch_get_enabled(watch)?"enabled":"disabled");
}
if (info->watch < 0) {
VIR_FREE(info);
return 0;
}
dbus_watch_set_data(watch, info, virDBusWatchFree);
return 1;
}
static void virDBusRemoveWatch(DBusWatch *watch,
void *data ATTRIBUTE_UNUSED)
{
struct virDBusWatch *info;
info = dbus_watch_get_data(watch);
(void)virEventRemoveHandle(info->watch);
}
static void virDBusToggleWatch(DBusWatch *watch,
void *data ATTRIBUTE_UNUSED)
{
int flags = 0;
struct virDBusWatch *info;
if (dbus_watch_get_enabled(watch))
flags = virDBusTranslateWatchFlags(dbus_watch_get_flags(watch));
info = dbus_watch_get_data(watch);
