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