static void registerUnregisterFds() {
int fd, fdMax;
FD_ZERO(&curlSrc->fdRead);
FD_ZERO(&curlSrc->fdWrite);
FD_ZERO(&curlSrc->fdExc);
curlSrc->fdMax = -1;
/* What fds does libcurl want us to poll? */
curl_multi_fdset(curlSrc->multiHandle, &curlSrc->fdRead,
&curlSrc->fdWrite, &curlSrc->fdExc, &curlSrc->fdMax);
if ((curlSrc->fdMax < -1) || (curlSrc->fdMax > GLIBCURL_FDMAX)) {
DEBUG_FAILURE(("registerUnregisterFds: fdMax=%d\n", curlSrc->fdMax));
}
/*fprintf(stderr, "registerUnregisterFds: fdMax=%d\n", curlSrc->fdMax);*/
assert(curlSrc->fdMax >= -1 && curlSrc->fdMax <= GLIBCURL_FDMAX);
fdMax = curlSrc->fdMax;
if (fdMax < curlSrc->lastPollFdMax) fdMax = curlSrc->lastPollFdMax;
/* Has the list of required events for any of the fds changed? */
for (fd = 0; fd <= fdMax; ++fd) {
gushort events = 0;
if (FD_ISSET(fd, &curlSrc->fdRead)) events |= GLIBCURL_READ;
if (FD_ISSET(fd, &curlSrc->fdWrite)) events |= GLIBCURL_WRITE;
if (FD_ISSET(fd, &curlSrc->fdExc)) events |= GLIBCURL_EXC;
/* List of events unchanged => no (de)registering */
if (events == curlSrc->lastPollFd[fd].events) continue;
DD((stdout, "registerUnregisterFds: fd %d: old events %x, "
"new events %x\n", fd, curlSrc->lastPollFd[fd].events, events));
/* fd is already a lastPollFd, but event type has changed => do nothing.
Due to the implementation of g_main_context_query(), the new event
flags will be picked up automatically. */
if (events != 0 && curlSrc->lastPollFd[fd].events != 0) {
curlSrc->lastPollFd[fd].events = events;
continue;
}
curlSrc->lastPollFd[fd].events = events;
/* Otherwise, (de)register as appropriate */
if (events == 0) {
g_source_remove_poll(&curlSrc->source, &curlSrc->lastPollFd[fd]);
curlSrc->lastPollFd[fd].revents = 0;
D((stderr, "unregister fd %d\n", fd));
} else {
g_source_add_poll(&curlSrc->source, &curlSrc->lastPollFd[fd]);
D((stderr, "register fd %d\n", fd));
}
}
curlSrc->lastPollFdMax = curlSrc->fdMax;
}
static gboolean source_dispatch(GSource *source, GSourceFunc callback,
gpointer data)
{
struct timeval zerotimeout = {
.tv_sec = 0,
.tv_usec = 0,
};
/* FIXME error handling */
fp_handle_events_timeout(&zerotimeout);
/* FIXME whats the return value used for? */
return TRUE;
}
static void source_finalize(GSource *source)
{
struct fdsource *_fdsource = (struct fdsource *) source;
GSList *elem = _fdsource->pollfds;
if (elem)
do {
GPollFD *pollfd = elem->data;
g_source_remove_poll((GSource *) _fdsource, pollfd);
g_slice_free(GPollFD, pollfd);
_fdsource->pollfds = g_slist_delete_link(_fdsource->pollfds, elem);
} while ((elem = g_slist_next(elem)));
g_slist_free(_fdsource->pollfds);
}
static GSourceFuncs sourcefuncs = {
.prepare = source_prepare,
.check = source_check,
.dispatch = source_dispatch,
.finalize = source_finalize,
};
struct fdsource *fdsource = NULL;
static void pollfd_add(int fd, short events)
{
GPollFD *pollfd = g_slice_new(GPollFD);
pollfd->fd = fd;
pollfd->events = 0;
pollfd->revents = 0;
if (events & POLLIN)
pollfd->events |= G_IO_IN;
if (events & POLLOUT)
pollfd->events |= G_IO_OUT;
fdsource->pollfds = g_slist_prepend(fdsource->pollfds, pollfd);
g_source_add_poll((GSource *) fdsource, pollfd);
}
static void
g_mdns_user_data_destroy (GMDNSUserData *ud)
{
g_return_if_fail (ud);
g_source_remove_poll (ud->source, ud->fd);
g_free (ud->fd);
g_source_destroy (ud->source);
DNSServiceRefDeallocate (ud->client);
g_free (ud);
}
static void glib_io_free(pa_io_event*e) {
g_assert(e);
g_assert(!e->dead);
e->dead = 1;
e->mainloop->io_events_please_scan++;
if (e->poll_fd_added) {
g_source_remove_poll(&e->mainloop->source, &e->poll_fd);
e->poll_fd_added = 0;
}
}
static void watch_free(AvahiWatch *w) {
assert(w);
assert(!w->dead);
if (w->pollfd_added) {
g_source_remove_poll(&w->glib_poll->source, &w->pollfd);
w->pollfd_added = FALSE;
}
w->dead = TRUE;
w->glib_poll->timeout_req_cleanup = TRUE;
}
GCHSource*
G_main_add_IPC_Channel(int priority, IPC_Channel* ch
, gboolean can_recurse
, gboolean (*dispatch)(IPC_Channel* source_data,
gpointer user_data)
, gpointer userdata
, GDestroyNotify notify)
{
GCHSource *chp;
GSource *source;
if( !ch ) {
cl_log(LOG_WARNING, "%s:%d: got null channel", __FUNCTION__,__LINE__);
return NULL;
}
source = g_source_new(&G_CH_SourceFuncs,
sizeof(GCHSource));
G_main_IPC_Channel_constructor(source,ch,userdata,notify);
chp = (GCHSource*)source;
chp->dispatch = dispatch;
g_source_set_priority(source, priority);
g_source_set_can_recurse(source, can_recurse);
chp->gsourceid = g_source_attach(source, NULL);
chp->description = "IPC channel";
if (chp->gsourceid == 0) {
g_source_remove_poll(source, &chp->infd);
if (!chp->fd_fdx) {
g_source_remove_poll(source, &chp->outfd);
}
g_source_unref(source);
source = NULL;
chp = NULL;
}
return chp;
}
static gboolean g_source_fd_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
GSourceFD *sfd = (GSourceFD *) source;
if (callback != NULL
&& !callback (user_data))
{
g_source_remove_poll (source, &sfd->poll_fd);
sfd->has_poll = FALSE;
return FALSE;
}
return TRUE;
}
/*
* Add an IPC_WaitConnection to the gmainloop world...
*/
GWCSource*
G_main_add_IPC_WaitConnection(int priority
, IPC_WaitConnection* wch
, IPC_Auth* auth_info
, gboolean can_recurse
, gboolean (*dispatch)(IPC_Channel* wch
, gpointer user_data)
, gpointer userdata
, GDestroyNotify notify)
{
GWCSource* wcp;
GSource * source = g_source_new(&G_WC_SourceFuncs,
sizeof(GWCSource));
wcp = (GWCSource*)source;
wcp->magno = MAG_GWCSOURCE;
wcp->maxdispatchdelayms = DEFAULT_MAXDELAY;
wcp->maxdispatchms = DEFAULT_MAXDISPATCH;
lc_store((wcp->detecttime), zero_longclock);
wcp->udata = userdata;
wcp->gpfd.fd = wch->ops->get_select_fd(wch);
wcp->gpfd.events = DEF_EVENTS;
wcp->gpfd.revents = 0;
wcp->wch = wch;
wcp->dnotify = notify;
wcp->auth_info = auth_info;
wcp->dispatch = dispatch;
g_source_add_poll(source, &wcp->gpfd);
g_source_set_priority(source, priority);
g_source_set_can_recurse(source, can_recurse);
wcp->gsourceid = g_source_attach(source, NULL);
wcp->description = "IPC wait for connection";
if (wcp->gsourceid == 0) {
g_source_remove_poll(source, &wcp->gpfd);
g_source_unref(source);
source = NULL;
wcp = NULL;
}
return wcp;
}
gboolean
G_main_del_fd(GFDSource* fdp)
{
GSource * source = (GSource*) fdp;
if (fdp->gsourceid <= 0) {
return FALSE;
}
g_source_remove_poll(source, &fdp->gpfd);
g_source_remove(fdp->gsourceid);
fdp->gsourceid = 0;
g_source_unref(source);
return TRUE;
}
/** ========================================================================
* The 'prepare' function of GSourceFuncs
*
* @param base
* @param timeout @see GSourceFuncs
*
* @return gboolean @see GSourceFuncs
*
* =========================================================================
*/
static gboolean
multi_fd_watch_prepare(GSource* base, gint* timeout)
{
PSL_LOG_DEBUGLOW("%s (watch=%p)", __func__, base);
PslMultiFdWatchSource* const source = (PslMultiFdWatchSource*)base;
/// Clear revents of our pollrecs
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, source->descTable);
while (g_hash_table_iter_next(&iter, &key, &value)) {
PslMultiFdDescriptor* const desc = (PslMultiFdDescriptor*)value;
desc->pollFd.revents = 0;
if (desc->pollFd.events) {
if (!desc->pollAdded) {
g_source_add_poll(base, &desc->pollFd);
desc->pollAdded = true;
}
}
else if (desc->pollAdded) {
g_source_remove_poll(base, &desc->pollFd);
desc->pollAdded = false;
}
PSL_LOG_DEBUGLOW(
"%s (watch=%p): iter: table=%p, desc=%p, fd=%d, " \
"monitoring GIOCondition=0x%lX",
__func__, source, source->descTable, desc, (int)desc->pollFd.fd,
(unsigned long)desc->pollFd.events);
}
/// Calc remaining timeout
*timeout = multi_fd_watch_update_expiry_time(source);
gboolean const readyNow = (0 == *timeout);
PSL_LOG_DEBUGLOW("%s (watch=%p): %s", __func__, base,
readyNow ? "READY" : "NOT READY");
return readyNow;
}
GFDSource*
G_main_add_fd(int priority, int fd, gboolean can_recurse
, gboolean (*dispatch)(int fd, gpointer user_data)
, gpointer userdata
, GDestroyNotify notify)
{
GSource* source = g_source_new(&G_fd_SourceFuncs,
sizeof(GFDSource));
GFDSource* ret = (GFDSource*)source;
ret->magno = MAG_GFDSOURCE;
ret->maxdispatchdelayms = DEFAULT_MAXDELAY;
ret->maxdispatchms = DEFAULT_MAXDISPATCH;
ret->udata = userdata;
ret->dispatch = dispatch;
ret->gpfd.fd = fd;
ret->gpfd.events = DEF_EVENTS;
ret->gpfd.revents = 0;
ret->dnotify = notify;
lc_store((ret->detecttime), zero_longclock);
g_source_add_poll(source, &ret->gpfd);
g_source_set_priority(source, priority);
g_source_set_can_recurse(source, can_recurse);
ret->gsourceid = g_source_attach(source, NULL);
ret->description = "file descriptor";
if (ret->gsourceid == 0) {
g_source_remove_poll(source, &ret->gpfd);
memset(ret, 0, sizeof(GFDSource));
g_source_unref(source);
source = NULL;
ret = NULL;
}
return ret;
}
void socketmanager::RegisterSockInterest(CURL *e, curl_socket_t s, int what) {
sock_gsource *sgs = (sock_gsource *) gs;
short events = 0;
switch (what) {
case CURL_POLL_NONE:
case CURL_POLL_REMOVE:
default:
events = 0;
break;
case CURL_POLL_IN:
events = G_IO_IN | G_IO_PRI | G_IO_ERR;
break;
case CURL_POLL_OUT:
events = G_IO_OUT | G_IO_ERR;
break;
case CURL_POLL_INOUT:
events = G_IO_IN | G_IO_PRI | G_IO_OUT | G_IO_ERR;
break;
}
auto egp = sgs->sm->sockpollmap.find(s);
GPollFD *gpfd = nullptr;
if (egp != sgs->sm->sockpollmap.end()) {
gpfd = &(egp->second);
g_source_remove_poll(sgs, gpfd);
if (!events) {
sgs->sm->sockpollmap.erase(egp);
}
} else if (events) {
gpfd = &sgs->sm->sockpollmap[s];
}
if (events) {
gpfd->fd = s;
gpfd->events = events;
gpfd->revents = 0;
g_source_add_poll(sgs, gpfd);
}
}
/*
* Someone is trying to connect.
* Try to accept the connection and notify the user.
*/
static gboolean
G_WC_dispatch(GSource* source,
GSourceFunc callback,
gpointer user_data)
{
GWCSource* wcp = (GWCSource*)source;
IPC_Channel* ch;
gboolean rc = TRUE;
int count = 0;
longclock_t dispstart;
g_assert(IS_WCSOURCE(wcp));
CHECK_DISPATCH_DELAY(wcp);
while(1) {
ch = wcp->wch->ops->accept_connection(wcp->wch, wcp->auth_info);
if (ch == NULL) {
if (errno == EBADF) {
cl_perror("%s: Stopping accepting connections(socket=%d)!!"
, __FUNCTION__, wcp->gpfd.fd);
rc = FALSE;
}
break;
}
++count;
if(!wcp->dispatch) {
continue;
}
rc = wcp->dispatch(ch, wcp->udata);
if(!rc) {
g_source_remove_poll(source, &wcp->gpfd);
g_source_unref(source);
break;
}
}
CHECK_DISPATCH_TIME(wcp);
return rc;
}
static void
dx_dinput_finalize (GObject *object)
{
ControllerDXDInput *controller = CONTROLLER_DX_DINPUT (object);
if (controller->source != NULL)
{
g_source_remove_poll (controller->source, controller->pollfd);
g_source_remove (g_source_get_id (controller->source));
g_source_unref (controller->source);
}
if (controller->didevice8)
IDirectInputDevice8_SetEventNotification (controller->didevice8, NULL);
if (controller->format != NULL)
{
g_free (controller->format->rgodf);
g_free (controller->format);
controller->format = NULL;
}
g_free (controller->prevdata);
controller->prevdata = NULL;
if (controller->event != NULL)
{
CloseHandle (controller->event);
controller->event = 0;
}
if (controller->store)
{
g_object_unref (controller->store);
controller->store = NULL;
}
G_OBJECT_CLASS (controller_dx_dinput_parent_class)->finalize (object);
}
QEventDispatcherGlib::~QEventDispatcherGlib()
{
Q_D(QEventDispatcherGlib);
// destroy all timer sources
qDeleteAll(d->timerSource->timerList);
d->timerSource->timerList.~QTimerInfoList();
g_source_destroy(&d->timerSource->source);
g_source_unref(&d->timerSource->source);
d->timerSource = 0;
#ifndef QT_WEBOS
g_source_destroy(&d->idleTimerSource->source);
#endif // QT_WEBOS
g_source_unref(&d->idleTimerSource->source);
d->idleTimerSource = 0;
// destroy socket notifier source
for (int i = 0; i < d->socketNotifierSource->pollfds.count(); ++i) {
GPollFDWithQSocketNotifier *p = d->socketNotifierSource->pollfds[i];
g_source_remove_poll(&d->socketNotifierSource->source, &p->pollfd);
delete p;
}
d->socketNotifierSource->pollfds.~QList<GPollFDWithQSocketNotifier *>();
g_source_destroy(&d->socketNotifierSource->source);
g_source_unref(&d->socketNotifierSource->source);
d->socketNotifierSource = 0;
// destroy post event source
g_source_destroy(&d->postEventSource->source);
g_source_unref(&d->postEventSource->source);
d->postEventSource = 0;
Q_ASSERT(d->mainContext != 0);
#if GLIB_CHECK_VERSION (2, 22, 0)
g_main_context_pop_thread_default (d->mainContext);
#endif
g_main_context_unref(d->mainContext);
d->mainContext = 0;
}
static void session_setup_g_source(Session *s) {
if (!s->ggs) return;
if (s->g_source && s->g_pollfd.fd != s->ggs->fd) {
g_source_remove_poll(s->g_source, &s->g_pollfd);
}
if (!s->g_source) {
s->g_source = g_source_new(&source_funcs, sizeof(Source));
((Source *)(gpointer)s->g_source)->session=s;
g_source_attach(s->g_source,g_main_loop_get_context(main_loop));
}
s->g_pollfd.events=G_IO_ERR|G_IO_HUP|G_IO_NVAL;
if (s->ggs->check&GG_CHECK_READ) s->g_pollfd.events|=G_IO_IN;
if (s->ggs->check&GG_CHECK_WRITE) s->g_pollfd.events|=G_IO_OUT;
if (s->g_pollfd.fd != s->ggs->fd) {
s->g_pollfd.fd=s->ggs->fd;
if (s->g_pollfd.fd!=-1) g_source_add_poll(s->g_source, &s->g_pollfd);
}
}
static void pollfd_removed_cb(int fd)
{
GSList *elem = fdsource->pollfds;
g_message("no longer monitoring fd %d", fd);
if (!elem) {
g_warning("cannot remove from list as list is empty?");
return;
}
do {
GPollFD *pollfd = elem->data;
if (pollfd->fd != fd)
continue;
g_source_remove_poll((GSource *) fdsource, pollfd);
g_slice_free(GPollFD, pollfd);
fdsource->pollfds = g_slist_delete_link(fdsource->pollfds, elem);
return;
} while ((elem = g_slist_next(elem)));
g_error("couldn't find fd %d in list\n", fd);
}
static gboolean
port_check(GSource *source)
{
PSource *pn = (PSource *)source;
uint_t nget;
if (pn->pending) {
pn->pending = FALSE;
g_source_add_poll(source, PGPFD(source));
g_source_unref(source);
return FALSE;
}
if (!(PGPFD(pn)->revents & G_IO_IN))
return FALSE;
if (port_getn(PGPFD(source)->fd, NULL, 0, &nget, 0) == 0) {
if (nget - pn->pending_events > EXPECT_INC_EVENTS(pn)) {
/* Sleep for a while. */
pn->pending_events = nget;
pn->event_growing_factor ++;
pn->pending = TRUE;
g_source_ref(source);
g_source_remove_poll(source, PGPFD(source));
g_timeout_add(SLEEP_BASE_TIME,
(GSourceFunc)port_check,
(gpointer)pn);
return FALSE;
}
}
pn->pending_events = 0;
pn->event_growing_factor = 0;
return TRUE;
}
static gboolean
hm_watch_rw_dispatch(HmWatch *watch, gpointer user_data)
{
HmWatchFuncs *funcs;
gint err = 0, timeout = 1;
socklen_t len = sizeof(err);
gchar buf[MAX_IO_BUFFER_SIZE];
funcs = watch->funcs;
BUG_ON(!funcs);
if (watch->r_fd.revents & READ_COND)
{
timeout = 0;
if (watch->r_fd.revents & READ_ERR)
{
getsockopt(watch->r_fd.fd, SOL_SOCKET, SO_ERROR, &err, &len);
err = -err;
goto read_error;
}
for (;;)
{
if (watch->killed)
return FALSE; /* end the loop if killed, funcs->recv() may drop lock. */
err = hm_connection_read(watch->conn, buf, MAX_IO_BUFFER_SIZE);
if (err == 0)
{
goto conn_reset;
}
else if (err > 0)
{
if (funcs->recv)
{
if ((err = (*funcs->recv)(watch, buf, err)))
{
goto read_error;
}
}
else
{
watch->r_fd.revents = 0; /* no reader */
g_source_remove_poll((GSource*)watch, &watch->r_fd);
break; /* data will stay in the sock buffer */
}
}
else
{
if (err == -EAGAIN)
break;
goto read_error;
}
}
}
if (watch->w_fd.revents & WRITE_COND)
{
timeout = 0;
if (G_UNLIKELY(hm_connection_is_ingrogress(watch->conn, 1)))
{
if (getsockopt(watch->w_fd.fd, SOL_SOCKET, SO_ERROR, &err, &len))
{
hm_warning("getsockopt() after connect() failed");
err = -errno;
goto write_error;
}
if (err)
{
err = -err;
goto write_error;
}
watch->w_fd.revents = 0;
g_source_remove_poll((GSource*)watch, &watch->w_fd);
g_source_add_poll((GSource*)watch, &watch->r_fd);
g_mutex_unlock(watch->lock); /* drop the lock*/
hm_watch_on_establish(watch);
g_mutex_lock(watch->lock);
}
else
{
if (watch->w_fd.revents & WRITE_ERR)
{
len = sizeof(err);
getsockopt(watch->w_fd.fd, SOL_SOCKET, SO_ERROR, &err, &len);
err = -err;
goto write_error;
}
err = hm_net_buf_flush(watch->buffer, watch);
if (!err) /* all data flushed */
{
watch->w_fd.revents = 0;
g_source_remove_poll((GSource*)watch, &watch->w_fd);
watch->w_pending = 0;
}
else
{
if (err < 0)
goto write_error;
}
}
}
if (timeout)
{
hm_print(
"Net IO '%p' timeout.", NET_IO(watch)
);
__hm_watch_error(watch, 0, -E_CONNTIMEOUT);
return FALSE;
}
return TRUE;
conn_reset:
__hm_watch_close(watch, 1);
return FALSE;
read_error:
__hm_watch_error(watch, 0, err);
return FALSE;
write_error:
__hm_watch_error(watch, 1, err);
return FALSE;
}
void main_loop_test()
{
GMainContext *default_context;
int depth;
int id;
GTimeVal time ={0,};
int user_data = 0,fd_data = 0;
GPollFD pollfd;
GSource *source3;
GSourceFuncs SourceFuncs =
{
prepare,
check,
dispatch,
NULL
};
GSourceFuncs fd_SourceFuncs =
{
fd_prepare,
fd_check,
fd_dispatch,
NULL
};
e1_complete = FALSE;
e2_complete = FALSE;
pipe(fd);
pollfd.fd = fd[0];
pollfd.events = G_IO_IN | G_IO_HUP | G_IO_ERR;
pollfd.revents = 0;
pthread_create(&thread1, NULL, thread_function, NULL);
context = g_main_context_new();
//g_main_context_add_poll(context,&pollfd,0);
source1 = g_source_new(&SourceFuncs,sizeof(GSource));
g_source_set_callback(source1,(GSourceFunc)my_callback,&user_data,NULL);
id = g_source_attach(source1,context);
g_assert(g_source_get_id(source1) == id);
g_source_set_priority(source1,0);
g_assert(g_source_get_priority(source1) == 0);
loop = g_main_loop_new(context, FALSE);
default_context = g_main_loop_get_context(loop);
//checks g_main_loop_get_context
g_assert(default_context == context);
//checks g_main_loop_is_running
g_assert(g_main_loop_is_running(loop) == FALSE);
depth = g_main_depth();
//checks g_main_depth
g_assert(depth == 0);
g_source_get_current_time(source1,&time);
g_assert(time.tv_usec > 0);
g_source_set_can_recurse(source1,TRUE);
g_assert(g_source_get_can_recurse(source1) == TRUE);
source2 = g_source_new(&fd_SourceFuncs,sizeof(GSource));
g_source_set_callback(source2,(GSourceFunc)fd_callback,&fd_data,NULL);
g_source_add_poll(source2,&pollfd);
g_source_remove_poll(source2,&pollfd);
// checks g_source_remove_poll
g_assert(source2->poll_fds == NULL);
g_source_add_poll(source2,&pollfd);
// checks whether g_source_add_poll is successful.
// one more check is done in fd_callback.
// If that function is callled we are sure that add poll was successful
g_assert(source2->poll_fds->data == &pollfd);
source3 = g_source_ref(source2);
g_assert(source3 == source2 && source2->ref_count == 2);
g_source_unref(source3);
id = g_source_attach(source2,context);
//checks g_main_context_pending
g_assert(g_main_context_pending(context));
g_main_loop_run(loop);
// ref is called here. Thats why two unrefs are called. If the 2nd unref is
// callled with the unref, code should crash
g_main_loop_ref(loop);
g_main_loop_unref(loop);
g_main_loop_unref(loop);
//checks the number of times the call back function is called
g_assert(user_data == 100);
// checks whether set poll was successful and call back for the same
// was called
g_assert(fd_data == 1);
}
/*
* Some kind of event occurred - notify the user.
*/
gboolean
G_CH_dispatch_int(GSource * source,
GSourceFunc callback,
gpointer user_data)
{
GCHSource* chp = (GCHSource*)source;
longclock_t dispstart;
longclock_t resume_start = zero_longclock;
g_assert(IS_CHSOURCE(chp));
CHECK_DISPATCH_DELAY(chp);
if (chp->dontread){
return TRUE;
}
/* Is output now unblocked?
*
* If so, turn off OUTPUT_EVENTS to avoid going into
* a tight poll(2) loop.
*/
if (chp->fd_fdx) {
if (chp->infd.revents & OUTPUT_EVENTS) {
chp->infd.events &= ~OUTPUT_EVENTS;
}
}else if (chp->outfd.revents & OUTPUT_EVENTS) {
chp->outfd.events &= ~OUTPUT_EVENTS;
}
if (ANYDEBUG) {
resume_start = time_longclock();
}
chp->ch->ops->resume_io(chp->ch);
if (ANYDEBUG) {
longclock_t resume_end = time_longclock();
unsigned long ms;
ms = longclockto_ms(sub_longclock(resume_end
, resume_start));
if (ms > 10) {
cl_log(LOG_WARNING
, "%s: resume_io() for %s took %lu ms"
, __FUNCTION__
, chp->description, ms);
}
}
if(chp->dispatch && chp->ch->ops->is_message_pending(chp->ch)) {
if(!(chp->dispatch(chp->ch, chp->udata))){
g_source_remove_poll(source, &chp->infd);
if (!chp->fd_fdx) {
g_source_remove_poll(source, &chp->outfd);
}
CHECK_DISPATCH_TIME(chp);
g_source_unref(source);
return FALSE;
}
}
CHECK_DISPATCH_TIME(chp);
if (chp->ch->ch_status == IPC_DISCONNECT){
return FALSE;
}
return TRUE;
}
/**
* Updates all registered GPollFD objects, unregisters old ones,
* registers new ones.
*/
static void
http_client_update_fds(void)
{
fd_set rfds, wfds, efds;
int max_fd;
CURLMcode mcode;
GSList *fds;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&efds);
mcode = curl_multi_fdset(http_client.multi, &rfds, &wfds,
&efds, &max_fd);
if (mcode != CURLM_OK) {
g_warning("curl_multi_fdset() failed: %s\n",
curl_multi_strerror(mcode));
return;
}
fds = http_client.fds;
http_client.fds = NULL;
while (fds != NULL) {
GPollFD *poll_fd = fds->data;
gushort events = http_client_fd_events(poll_fd->fd, &rfds,
&wfds, &efds);
assert(poll_fd->events != 0);
fds = g_slist_remove(fds, poll_fd);
if (events != poll_fd->events)
g_source_remove_poll(http_client.source, poll_fd);
if (events != 0) {
if (events != poll_fd->events) {
poll_fd->events = events;
g_source_add_poll(http_client.source, poll_fd);
}
http_client.fds = g_slist_prepend(http_client.fds,
poll_fd);
} else {
g_free(poll_fd);
}
}
for (int fd = 0; fd <= max_fd; ++fd) {
gushort events = http_client_fd_events(fd, &rfds,
&wfds, &efds);
if (events != 0) {
GPollFD *poll_fd = g_new(GPollFD, 1);
poll_fd->fd = fd;
poll_fd->events = events;
g_source_add_poll(http_client.source, poll_fd);
http_client.fds = g_slist_prepend(http_client.fds,
poll_fd);
}
}
}
static CoglBool
cogl_glib_source_prepare (GSource *source, int *timeout)
{
CoglGLibSource *cogl_source = (CoglGLibSource *) source;
CoglPollFD *poll_fds;
int n_poll_fds;
int64_t cogl_timeout;
int age;
int i;
age = cogl_poll_renderer_get_info (cogl_source->renderer,
&poll_fds,
&n_poll_fds,
&cogl_timeout);
/* We have to be careful not to call g_source_add/remove_poll unless
* the FDs have changed because it will cause the main loop to
* immediately wake up. If we call it every time the source is
* prepared it will effectively never go idle. */
if (age != cogl_source->poll_fds_age)
{
/* Remove any existing polls before adding the new ones */
for (i = 0; i < cogl_source->poll_fds->len; i++)
{
GPollFD *poll_fd = &g_array_index (cogl_source->poll_fds, GPollFD, i);
g_source_remove_poll (source, poll_fd);
}
g_array_set_size (cogl_source->poll_fds, n_poll_fds);
for (i = 0; i < n_poll_fds; i++)
{
GPollFD *poll_fd = &g_array_index (cogl_source->poll_fds, GPollFD, i);
poll_fd->fd = poll_fds[i].fd;
g_source_add_poll (source, poll_fd);
}
}
cogl_source->poll_fds_age = age;
/* Update the events */
for (i = 0; i < n_poll_fds; i++)
{
GPollFD *poll_fd = &g_array_index (cogl_source->poll_fds, GPollFD, i);
poll_fd->events = poll_fds[i].events;
poll_fd->revents = 0;
}
if (cogl_timeout == -1)
{
*timeout = -1;
cogl_source->expiration_time = -1;
}
else
{
/* Round up to ensure that we don't try again too early */
*timeout = (cogl_timeout + 999) / 1000;
cogl_source->expiration_time = (g_source_get_time (source) +
cogl_timeout);
}
return *timeout == 0;
}
/*
* Unregister a previously registered CtkEvent from its corresponding event
* source. If the event source becomes empty (no CtkEvents attached to it), this
* function also destroys the event source and its corresponding event handle.
*/
static void ctk_event_unregister_source(CtkEvent *ctk_event)
{
CtrlTarget *ctrl_target = ctk_event->ctrl_target;
NvCtrlEventHandle *event_handle = NvCtrlGetEventHandle(ctrl_target);
CtkEventSource *event_source;
CtkEventNode *event_node;
if (!event_handle) {
return;
}
/* Do we have an event source for this event handle? */
event_source = find_event_source(event_handle);
if (!event_source) {
return;
}
/* Remove the ctk_event object from the source's list of event objects */
event_node = event_source->ctk_events;
if (event_node->ctk_event == ctk_event) {
event_source->ctk_events = event_node->next;
}
else {
CtkEventNode *prev = event_node;
event_node = event_node->next;
while (event_node) {
if (event_node->ctk_event == ctk_event) {
prev->next = event_node->next;
break;
}
prev = event_node;
event_node = event_node->next;
}
}
if (!event_node) {
return;
}
g_free(event_node);
/* destroy the event source if empty */
if (event_source->ctk_events == NULL) {
GSource *source = (GSource *)event_source;
if (event_sources == event_source) {
event_sources = event_source->next;
}
else {
CtkEventSource *cur;
for (cur = event_sources; cur; cur = cur->next) {
if (cur->next == event_source) {
cur->next = event_source->next;
break;
}
}
}
NvCtrlCloseEventHandle(event_source->event_handle);
g_source_remove_poll(source, &(event_source->event_poll_fd));
g_source_destroy(source);
g_source_unref(source);
}
}
XlibEventSource::~XlibEventSource()
{
g_source_remove_poll(&m_source->source, &m_pollFD);
g_source_destroy(&m_source->source);
}
static void g_source_fd_finalize (GSource *source)
{
GSourceFD *sfd = (GSourceFD *) source;
if (sfd->has_poll)
g_source_remove_poll (source, &sfd->poll_fd);
}
/** @internal
*
* Register a @c su_wait_t object. The wait object, a callback function and
* a argument pointer is stored in the port object. The callback function
* will be called when the wait object is signaled.
*
* Please note if identical wait objects are inserted, only first one is
* ever signalled.
*
* @param self pointer to port
* @param root pointer to root object
* @param waits pointer to wait object
* @param callback callback function pointer
* @param arg argument given to callback function when it is invoked
* @param priority relative priority of the wait object
* (0 is normal, 1 important, 2 realtime)
*
* @return
* The function @su_source_register returns nonzero index of the wait object,
* or -1 upon an error. */
int su_source_register(su_port_t *self,
su_root_t *root,
su_wait_t *wait,
su_wakeup_f callback,
su_wakeup_arg_t *arg,
int priority)
{
unsigned i, j, I;
unsigned n;
enter;
assert(SU_SOURCE_OWN_THREAD(self));
n = self->sup_n_waits;
if (n >= self->sup_size_waits) {
/* Reallocate size arrays */
unsigned size;
unsigned *indices;
su_wait_t *waits;
su_wakeup_f *wait_cbs;
su_wakeup_arg_t **wait_args;
su_root_t **wait_tasks;
if (self->sup_size_waits == 0)
size = SU_WAIT_MIN;
else
size = 2 * self->sup_size_waits;
indices = realloc(self->sup_indices, size * sizeof(*indices));
if (indices) {
self->sup_indices = indices;
for (i = self->sup_size_waits; i < size; i++)
indices[i] = UINT_MAX;
}
for (i = 0; i < self->sup_n_waits; i++)
g_source_remove_poll(self->sup_source, (GPollFD*)&self->sup_waits[i]);
waits = realloc(self->sup_waits, size * sizeof(*waits));
if (waits)
self->sup_waits = waits;
for (i = 0; i < self->sup_n_waits; i++)
g_source_add_poll(self->sup_source, (GPollFD*)&waits[i]);
wait_cbs = realloc(self->sup_wait_cbs, size * sizeof(*wait_cbs));
if (wait_cbs)
self->sup_wait_cbs = wait_cbs;
wait_args = realloc(self->sup_wait_args, size * sizeof(*wait_args));
if (wait_args)
self->sup_wait_args = wait_args;
/* Add sup_wait_roots array, if needed */
wait_tasks = realloc(self->sup_wait_roots, size * sizeof(*wait_tasks));
if (wait_tasks)
self->sup_wait_roots = wait_tasks;
if (!(indices && waits && wait_cbs && wait_args && wait_tasks)) {
return -1;
}
self->sup_size_waits = size;
}
self->sup_n_waits++;
if (priority > 0) {
/* Insert */
for (; n > 0; n--) {
g_source_remove_poll(self->sup_source, (GPollFD*)&self->sup_waits[n-1]);
self->sup_waits[n] = self->sup_waits[n-1];
g_source_add_poll(self->sup_source, (GPollFD*)&self->sup_waits[n]);
self->sup_wait_cbs[n] = self->sup_wait_cbs[n-1];
self->sup_wait_args[n] = self->sup_wait_args[n-1];
self->sup_wait_roots[n] = self->sup_wait_roots[n-1];
}
}
else {
/* Append - no need to move anything */
}
self->sup_waits[n] = *wait;
g_source_add_poll(self->sup_source, (GPollFD*)&self->sup_waits[n]);
self->sup_wait_cbs[n] = callback;
self->sup_wait_args[n] = arg;
self->sup_wait_roots[n] = root;
I = self->sup_max_index;
for (i = 0; i < I; i++)
if (self->sup_indices[i] == UINT_MAX)
break;
else if (self->sup_indices[i] >= n)
self->sup_indices[i]++;
if (i == I)
self->sup_max_index++;
if (n + 1 < self->sup_n_waits)
for (j = i; j < I; j++)
if (self->sup_indices[j] != UINT_MAX &&
self->sup_indices[j] >= n)
self->sup_indices[j]++;
self->sup_indices[i] = n;
self->sup_registers++;
return i + 1; /* 0 is failure */
}
/** Unregister a su_wait_t object.
*
* The function su_source_unregister() unregisters a su_wait_t object. The
* wait object, a callback function and a argument are removed from the
* port object.
*
* @param self - pointer to port object
* @param root - pointer to root object
* @param wait - pointer to wait object
* @param callback - callback function pointer (may be NULL)
* @param arg - argument given to callback function when it is invoked
* (may be NULL)
*
* @return Nonzero index of the wait object, or -1 upon an error.
*/
int su_source_unregister(su_port_t *self,
su_root_t *root,
su_wait_t *wait,
su_wakeup_f callback, /* XXX - ignored */
su_wakeup_arg_t *arg)
{
unsigned n, N;
unsigned i, I, j, *indices;
enter;
assert(self);
assert(SU_SOURCE_OWN_THREAD(self));
i = (unsigned)-1;
N = self->sup_n_waits;
I = self->sup_max_index;
indices = self->sup_indices;
for (n = 0; n < N; n++) {
if (SU_WAIT_CMP(wait[0], self->sup_waits[n]) != 0)
continue;
/* Found - delete it */
if (indices[n] == n)
i = n;
else for (i = 0; i < I; i++)
if (indices[i] == n)
break;
assert(i < I);
indices[i] = UINT_MAX;
g_source_remove_poll(self->sup_source, (GPollFD*)&self->sup_waits[n]);
self->sup_n_waits = N = N - 1;
if (n < N)
for (j = 0; j < I; j++)
if (self->sup_indices[j] != UINT_MAX &&
self->sup_indices[j] > n)
self->sup_indices[j]--;
for (; n < N; n++) {
g_source_remove_poll(self->sup_source, (GPollFD*)&self->sup_waits[n+1]);
self->sup_waits[n] = self->sup_waits[n+1];
g_source_add_poll(self->sup_source, (GPollFD*)&self->sup_waits[n]);
self->sup_wait_cbs[n] = self->sup_wait_cbs[n+1];
self->sup_wait_args[n] = self->sup_wait_args[n+1];
self->sup_wait_roots[n] = self->sup_wait_roots[n+1];
}
i += 1; /* 0 is failure */
if (i == I)
self->sup_max_index--;
break;
}
self->sup_registers++;
return (int)i;
}
