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