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_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 *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; }
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 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 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; }
static void remove_watch(DBusWatch *watch, void *data) { if (dbus_watch_get_enabled(watch)) return; /* will trigger watch_info_free() */ dbus_watch_set_data(watch, NULL, NULL); }
static void io_handler_source_finalized (gpointer data) { IOHandler *handler = data; if (handler->watch) dbus_watch_set_data (handler->watch, NULL, NULL); g_free (handler); }
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); }
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); }
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); }
static dbus_bool_t pcmk_dbus_watch_add(DBusWatch *watch, void *data){ int fd = dbus_watch_get_unix_fd(watch); mainloop_io_t *client = mainloop_add_fd( "dbus", G_PRIORITY_DEFAULT, fd, watch, &pcmk_dbus_cb); crm_trace("Added watch %p with fd=%d to client %p", watch, fd, client); dbus_watch_set_data(watch, client, NULL); return TRUE; }
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 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); }
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 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; }
/* Callback: "libdbus needs a new watch to be monitored by the main loop" */ static dbus_bool_t add_watch(DBusWatch *watch, void* data) { log_debug("%s(watch:%p, data)", __func__, watch); watch_app_info_t* app_info = (watch_app_info_t*)xzalloc(sizeof(*app_info)); dbus_watch_set_data(watch, app_info, free); int fd = dbus_watch_get_unix_fd(watch); log_debug(" dbus_watch_get_unix_fd():%d", fd); app_info->channel = g_io_channel_unix_new(fd); /* _unconditionally_ adding it to event loop would be an error */ toggled_watch(watch, data); return TRUE; }
/* DBusAddWatchFunction callback for pa mainloop */ static dbus_bool_t add_watch(DBusWatch *watch, void *data) { pa_dbus_wrap_connection *c = data; pa_io_event *ev; pa_assert(watch); pa_assert(c); ev = c->mainloop->io_new( c->mainloop, dbus_watch_get_unix_fd(watch), get_watch_flags(watch), handle_io_event, watch); dbus_watch_set_data(watch, ev, NULL); return TRUE; }
dbus_bool_t DBusWatcher::AddWatchFunction(DBusWatch* aWatch, void* aData) { MOZ_ASSERT(!NS_IsMainThread()); RawDBusConnection* connection = static_cast<RawDBusConnection*>(aData); DBusWatcher* dbusWatcher = new DBusWatcher(connection, aWatch); dbus_watch_set_data(aWatch, dbusWatcher, DBusWatcher::FreeFunction); if (dbus_watch_get_enabled(aWatch)) { dbusWatcher->StartWatching(); } return TRUE; }
/** * Decrements the reference count of a DBusWatch object * and finalizes the object if the count reaches zero. * * @param watch the watch object. */ void _dbus_watch_unref (DBusWatch *watch) { _dbus_assert (watch != NULL); _dbus_assert (watch->refcount > 0); watch->refcount -= 1; if (watch->refcount == 0) { dbus_watch_set_data (watch, NULL, NULL); /* call free_data_function */ if (watch->free_handler_data_function) (* watch->free_handler_data_function) (watch->handler_data); dbus_free (watch); } }
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 dbus_bool_t add_watch(DBusWatch *watch, void *data) { EpollData _cleanup_free_ *e = NULL; struct epoll_event ev; assert(watch); e = new0(EpollData, 1); if (!e) return FALSE; e->fd = dbus_watch_get_unix_fd(watch); e->object = watch; e->is_timeout = false; zero(ev); ev.events = bus_flags_to_events(watch); ev.data.ptr = e; if (epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_ADD, e->fd, &ev) < 0) { if (errno != EEXIST) return FALSE; /* Hmm, bloody D-Bus creates multiple watches on the * same fd. epoll() does not like that. As a dirty * hack we simply dup() the fd and hence get a second * one we can safely add to the epoll(). */ e->fd = dup(e->fd); if (e->fd < 0) return FALSE; if (epoll_ctl(PTR_TO_INT(data), EPOLL_CTL_ADD, e->fd, &ev) < 0) { close_nointr_nofail(e->fd); return FALSE; } e->fd_is_dupped = true; } dbus_watch_set_data(watch, e, NULL); e = NULL; /* prevent freeing */ return TRUE; }
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 dbus_bool_t AddWatchFunction(DBusWatch* watch, void* data) { struct ConnectionData* c = (struct ConnectionData*) data; struct WatchData* w; kprintf("AddWatchFunction\n"); w = CreateWatchData(watch); if (w == NULL) { return FALSE; } AddTail((struct List*) &c->watches, (struct Node*) w); dbus_watch_set_data(watch, w, NULL); return TRUE; }
dbus_bool_t watch_add( DBusWatch *dbus_watch, void *data ) { int esi; int edi; /* phantom */ IOWatchHandler *handler; int fd; unsigned int pcb_condition; unsigned int dbus_flags; if ( dbus_watch_get_enabled( &dbus_watch ) ) { pcb_condition = ( ( dbus_flags/*.1_1of4*/ & 2 ) & 255 ) != 0 ? ( 0 - ( ( ( dbus_flags & 1 ) < 1 ) & 1 ) ) + 13 : ( ( 0 - ( ( ( dbus_flags & 1 ) < 1 ) & 1 ) ) + 13 ) | 1; fd = dbus_watch_get_unix_fd( &dbus_watch ); *(int*)(malloc( 8 )) = dbus_watch; gui->watch_file( ebp_28, fd, pcb_condition, io_watch_handler_cb ); *(int*)malloc( 8 )/*.4*/ = ebp_28; dbus_watch_set_data( &dbus_watch, malloc( 8 ), &io_watch_handler_dbus_freed ); } return 1; }
/* DBusAddWatchFunction callback for pa mainloop */ static dbus_bool_t add_watch(DBusWatch *watch, void *data) { pa_dbus_wrap_connection *c = data; pa_io_event *ev; pa_assert(watch); pa_assert(c); ev = c->mainloop->io_new( c->mainloop, #if HAVE_DBUS_WATCH_GET_UNIX_FD dbus_watch_get_unix_fd(watch), #else dbus_watch_get_fd(watch), #endif get_watch_flags(watch), handle_io_event, watch); dbus_watch_set_data(watch, ev, NULL); return TRUE; }
/** * Decrements the reference count of a DBusWatch object * and finalizes the object if the count reaches zero. * * @param watch the watch object. */ void _dbus_watch_unref (DBusWatch *watch) { _dbus_assert (watch != NULL); _dbus_assert (watch->refcount > 0); watch->refcount -= 1; if (watch->refcount == 0) { if (_dbus_pollable_is_valid (watch->fd)) _dbus_warn ("this watch should have been invalidated"); dbus_watch_set_data (watch, NULL, NULL); /* call free_data_function */ if (watch->free_handler_data_function) (* watch->free_handler_data_function) (watch->handler_data); dbus_free (watch); } }
static dbus_bool_t add_watch(DBusWatch *watch, void *data) { struct daemon *daemon = data; struct watch *w; for (w = daemon->watches; w; w = w->next) if (w->watch == watch) return TRUE; if (!(w = malloc(sizeof(struct watch)))) return FALSE; w->watch = watch; w->next = daemon->watches; daemon->watches = w; dbus_watch_set_data (watch, (void *)daemon, NULL); 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 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; }
dbus_bool_t add_watch(DBusWatch *watch, void *data) { GIOCondition cond = G_IO_HUP | G_IO_ERR; GIOChannel *io; guint id; int fd, flags; if (!dbus_watch_get_enabled(watch)) return TRUE; fd = dbus_watch_get_fd(watch); io = g_io_channel_unix_new(fd); flags = dbus_watch_get_flags(watch); if (flags & DBUS_WATCH_READABLE) cond |= G_IO_IN; if (flags & DBUS_WATCH_WRITABLE) cond |= G_IO_OUT; id = g_io_add_watch(io, cond, watch_func, watch); dbus_watch_set_data(watch, (void *) id, NULL); return TRUE; }