X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=avahi-common%2Fsimple-watch.c;h=8df18dd7737236b2f3fa0956d025d912cfcd90c1;hb=9c0f9c65093cfa53d45f9b68782321eb8063a032;hp=770cf4fe67a8bb4c2458265bf4a8ddd45e62289e;hpb=deb6bcac8d1e1ecec4aafaee2d27dbe467e4f461;p=catta diff --git a/avahi-common/simple-watch.c b/avahi-common/simple-watch.c index 770cf4f..8df18dd 100644 --- a/avahi-common/simple-watch.c +++ b/avahi-common/simple-watch.c @@ -1,18 +1,16 @@ -/* $Id$ */ - /*** This file is part of avahi. - + avahi is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. - + avahi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. - + You should have received a copy of the GNU Lesser General Public License along with avahi; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 @@ -27,10 +25,13 @@ #include #include #include +#include +#include +#include -#include -#include - +#include "llist.h" +#include "malloc.h" +#include "timeval.h" #include "simple-watch.h" struct AvahiWatch { @@ -39,7 +40,7 @@ struct AvahiWatch { int idx; struct pollfd pollfd; - + AvahiWatchCallback callback; void *userdata; @@ -52,16 +53,17 @@ struct AvahiTimeout { int enabled; struct timeval expiry; - + AvahiTimeoutCallback callback; void *userdata; - + AVAHI_LLIST_FIELDS(AvahiTimeout, timeouts); }; struct AvahiSimplePoll { AvahiPoll api; AvahiPollFunc poll_func; + void *poll_func_userdata; struct pollfd* pollfds; int n_pollfds, max_pollfds, rebuild_pollfds; @@ -73,12 +75,64 @@ struct AvahiSimplePoll { int n_watches; AVAHI_LLIST_HEAD(AvahiWatch, watches); AVAHI_LLIST_HEAD(AvahiTimeout, timeouts); + + int wakeup_pipe[2]; + int wakeup_issued; + + int prepared_timeout; + + enum { + STATE_INIT, + STATE_PREPARING, + STATE_PREPARED, + STATE_RUNNING, + STATE_RAN, + STATE_DISPATCHING, + STATE_DISPATCHED, + STATE_QUIT, + STATE_FAILURE + } state; }; +void avahi_simple_poll_wakeup(AvahiSimplePoll *s) { + char c = 'W'; + assert(s); + + write(s->wakeup_pipe[1], &c, sizeof(c)); + s->wakeup_issued = 1; +} + +static void clear_wakeup(AvahiSimplePoll *s) { + char c[10]; /* Read ten at a time */ + + if (!s->wakeup_issued) + return; + + s->wakeup_issued = 0; + + for(;;) + if (read(s->wakeup_pipe[0], &c, sizeof(c)) != sizeof(c)) + break; +} + +static int set_nonblock(int fd) { + int n; + + assert(fd >= 0); + + if ((n = fcntl(fd, F_GETFL)) < 0) + return -1; + + if (n & O_NONBLOCK) + return 0; + + return fcntl(fd, F_SETFL, n|O_NONBLOCK); +} + static AvahiWatch* watch_new(const AvahiPoll *api, int fd, AvahiWatchEvent event, AvahiWatchCallback callback, void *userdata) { AvahiWatch *w; AvahiSimplePoll *s; - + assert(api); assert(fd >= 0); assert(callback); @@ -88,26 +142,22 @@ static AvahiWatch* watch_new(const AvahiPoll *api, int fd, AvahiWatchEvent event if (!(w = avahi_new(AvahiWatch, 1))) return NULL; - + + /* If there is a background thread running the poll() for us, tell it to exit the poll() */ + avahi_simple_poll_wakeup(s); + w->simple_poll = s; w->dead = 0; w->pollfd.fd = fd; w->pollfd.events = event; + w->pollfd.revents = 0; w->callback = callback; w->userdata = userdata; - if (s->n_pollfds < s->max_pollfds) { - /* If there's space for this pollfd, go on and allocate it */ - w->idx = s->n_pollfds++; - s->pollfds[w->idx] = w->pollfd; - - } else { - /* Unfortunately there's no place for this pollfd, so request a rebuild of the array */ - w->idx = -1; - s->rebuild_pollfds = 1; - } + w->idx = -1; + s->rebuild_pollfds = 1; AVAHI_LLIST_PREPEND(AvahiWatch, watches, s->watches, w); s->n_watches++; @@ -119,6 +169,9 @@ static void watch_update(AvahiWatch *w, AvahiWatchEvent events) { assert(w); assert(!w->dead); + /* If there is a background thread running the poll() for us, tell it to exit the poll() */ + avahi_simple_poll_wakeup(w->simple_poll); + w->pollfd.events = events; if (w->idx != -1) { @@ -143,17 +196,8 @@ static void remove_pollfd(AvahiWatch *w) { if (w->idx == -1) return; - - if (w->idx == w->simple_poll->n_pollfds-1) { - - /* This pollfd is at the end of the array, so we can easily cut it */ - - assert(w->simple_poll->n_pollfds > 0); - w->simple_poll->n_pollfds -= 1; - } else - /* Unfortunately this pollfd is in the middle of the array, so request a rebuild of it */ - w->simple_poll->rebuild_pollfds = 1; + w->simple_poll->rebuild_pollfds = 1; } static void watch_free(AvahiWatch *w) { @@ -161,8 +205,11 @@ static void watch_free(AvahiWatch *w) { assert(!w->dead); + /* If there is a background thread running the poll() for us, tell it to exit the poll() */ + avahi_simple_poll_wakeup(w->simple_poll); + remove_pollfd(w); - + w->dead = 1; w->simple_poll->n_watches --; w->simple_poll->watch_req_cleanup = 1; @@ -176,7 +223,7 @@ static void destroy_watch(AvahiWatch *w) { if (!w->dead) w->simple_poll->n_watches --; - + avahi_free(w); } @@ -197,7 +244,7 @@ static void cleanup_watches(AvahiSimplePoll *s, int all) { static AvahiTimeout* timeout_new(const AvahiPoll *api, const struct timeval *tv, AvahiTimeoutCallback callback, void *userdata) { AvahiTimeout *t; AvahiSimplePoll *s; - + assert(api); assert(callback); @@ -206,25 +253,30 @@ static AvahiTimeout* timeout_new(const AvahiPoll *api, const struct timeval *tv, if (!(t = avahi_new(AvahiTimeout, 1))) return NULL; - + + /* If there is a background thread running the poll() for us, tell it to exit the poll() */ + avahi_simple_poll_wakeup(s); + t->simple_poll = s; t->dead = 0; if ((t->enabled = !!tv)) t->expiry = *tv; - + t->callback = callback; t->userdata = userdata; AVAHI_LLIST_PREPEND(AvahiTimeout, timeouts, s->timeouts, t); - return t; } static void timeout_update(AvahiTimeout *t, const struct timeval *tv) { assert(t); assert(!t->dead); - + + /* If there is a background thread running the poll() for us, tell it to exit the poll() */ + avahi_simple_poll_wakeup(t->simple_poll); + if ((t->enabled = !!tv)) t->expiry = *tv; } @@ -233,6 +285,9 @@ static void timeout_free(AvahiTimeout *t) { assert(t); assert(!t->dead); + /* If there is a background thread running the poll() for us, tell it to exit the poll() */ + avahi_simple_poll_wakeup(t->simple_poll); + t->dead = 1; t->simple_poll->timeout_req_cleanup = 1; } @@ -265,7 +320,15 @@ AvahiSimplePoll *avahi_simple_poll_new(void) { if (!(s = avahi_new(AvahiSimplePoll, 1))) return NULL; - + + if (pipe(s->wakeup_pipe) < 0) { + avahi_free(s); + return NULL; + } + + set_nonblock(s->wakeup_pipe[0]); + set_nonblock(s->wakeup_pipe[1]); + s->api.userdata = s; s->api.watch_new = watch_new; @@ -276,18 +339,24 @@ AvahiSimplePoll *avahi_simple_poll_new(void) { s->api.timeout_new = timeout_new; s->api.timeout_free = timeout_free; s->api.timeout_update = timeout_update; - + s->pollfds = NULL; s->max_pollfds = s->n_pollfds = 0; - s->rebuild_pollfds = 0; + s->rebuild_pollfds = 1; s->quit = 0; s->n_watches = 0; s->events_valid = 0; - + s->watch_req_cleanup = 0; s->timeout_req_cleanup = 0; - avahi_simple_poll_set_func(s, NULL); + s->prepared_timeout = 0; + + s->state = STATE_INIT; + + s->wakeup_issued = 0; + + avahi_simple_poll_set_func(s, NULL, NULL); AVAHI_LLIST_HEAD_INIT(AvahiWatch, s->watches); AVAHI_LLIST_HEAD_INIT(AvahiTimeout, s->timeouts); @@ -301,29 +370,43 @@ void avahi_simple_poll_free(AvahiSimplePoll *s) { cleanup_timeouts(s, 1); cleanup_watches(s, 1); assert(s->n_watches == 0); - + avahi_free(s->pollfds); + + if (s->wakeup_pipe[0] >= 0) + close(s->wakeup_pipe[0]); + + if (s->wakeup_pipe[1] >= 0) + close(s->wakeup_pipe[1]); + avahi_free(s); } static int rebuild(AvahiSimplePoll *s) { AvahiWatch *w; int idx; - + assert(s); - if (s->n_watches > s->max_pollfds) { + if (s->n_watches+1 > s->max_pollfds) { struct pollfd *n; s->max_pollfds = s->n_watches + 10; - + if (!(n = avahi_realloc(s->pollfds, sizeof(struct pollfd) * s->max_pollfds))) return -1; s->pollfds = n; } - for (idx = 0, w = s->watches; w; w = w->watches_next) { + + s->pollfds[0].fd = s->wakeup_pipe[0]; + s->pollfds[0].events = POLLIN; + s->pollfds[0].revents = 0; + + idx = 1; + + for (w = s->watches; w; w = w->watches_next) { if(w->dead) continue; @@ -344,10 +427,10 @@ static AvahiTimeout* find_next_timeout(AvahiSimplePoll *s) { assert(s); for (t = s->timeouts; t; t = t->timeouts_next) { - + if (t->dead || !t->enabled) continue; - + if (!n || avahi_timeval_compare(&t->expiry, &n->expiry) < 0) n = t; } @@ -355,20 +438,24 @@ static AvahiTimeout* find_next_timeout(AvahiSimplePoll *s) { return n; } -static int start_timeout_callback(AvahiTimeout *t) { +static void timeout_callback(AvahiTimeout *t) { assert(t); assert(!t->dead); assert(t->enabled); t->enabled = 0; t->callback(t, t->userdata); - return 0; } -int avahi_simple_poll_iterate(AvahiSimplePoll *s, int timeout) { - int r; +int avahi_simple_poll_prepare(AvahiSimplePoll *s, int timeout) { AvahiTimeout *next_timeout; + assert(s); + assert(s->state == STATE_INIT || s->state == STATE_DISPATCHED || s->state == STATE_FAILURE); + s->state = STATE_PREPARING; + + /* Clear pending wakeup requests */ + clear_wakeup(s); /* Cleanup things first */ if (s->watch_req_cleanup) @@ -378,14 +465,17 @@ int avahi_simple_poll_iterate(AvahiSimplePoll *s, int timeout) { cleanup_timeouts(s, 0); /* Check whether a quit was requested */ - if (s->quit) + if (s->quit) { + s->state = STATE_QUIT; return 1; + } /* Do we need to rebuild our array of pollfds? */ if (s->rebuild_pollfds) - if (rebuild(s) < 0) + if (rebuild(s) < 0) { + s->state = STATE_FAILURE; return -1; - + } /* Calculate the wakeup time */ if ((next_timeout = find_next_timeout(s))) { @@ -393,15 +483,22 @@ int avahi_simple_poll_iterate(AvahiSimplePoll *s, int timeout) { int t; AvahiUsec usec; + if (next_timeout->expiry.tv_sec == 0 && + next_timeout->expiry.tv_usec == 0) { + + /* Just a shortcut so that we don't need to call gettimeofday() */ + timeout = 0; + goto finish; + } + gettimeofday(&now, NULL); usec = avahi_timeval_diff(&next_timeout->expiry, &now); if (usec <= 0) { /* Timeout elapsed */ - /* The events poll() returned in the last call are now no longer valid */ - s->events_valid = 0; - return start_timeout_callback(next_timeout); + timeout = 0; + goto finish; } /* Calculate sleep time. We add 1ms because otherwise we'd @@ -412,61 +509,141 @@ int avahi_simple_poll_iterate(AvahiSimplePoll *s, int timeout) { timeout = t; } - if ((r = s->poll_func(s->pollfds, s->n_pollfds, timeout)) < 0) - return -1; +finish: + s->prepared_timeout = timeout; + s->state = STATE_PREPARED; + return 0; +} + +int avahi_simple_poll_run(AvahiSimplePoll *s) { + assert(s); + assert(s->state == STATE_PREPARED || s->state == STATE_FAILURE); + + s->state = STATE_RUNNING; + + for (;;) { + errno = 0; + + if (s->poll_func(s->pollfds, s->n_pollfds, s->prepared_timeout, s->poll_func_userdata) < 0) { - /* The pollf events are now valid again */ + if (errno == EINTR) + continue; + + s->state = STATE_FAILURE; + return -1; + } + + break; + } + + /* The poll events are now valid again */ s->events_valid = 1; + /* Update state */ + s->state = STATE_RAN; + return 0; +} + +int avahi_simple_poll_dispatch(AvahiSimplePoll *s) { + AvahiTimeout *next_timeout; + AvahiWatch *w; + + assert(s); + assert(s->state == STATE_RAN); + s->state = STATE_DISPATCHING; + + /* We execute only on callback in every iteration */ + /* Check whether the wakeup time has been reached now */ - if (next_timeout) { - struct timeval now; - - gettimeofday(&now, NULL); + if ((next_timeout = find_next_timeout(s))) { - if (avahi_timeval_compare(&next_timeout->expiry, &now) <= 0) - /* Time elapsed */ - return start_timeout_callback(next_timeout); - } - - if (r > 0) { - AvahiWatch *w; + if (next_timeout->expiry.tv_sec == 0 && next_timeout->expiry.tv_usec == 0) { - /* Look for some kind of I/O event */ + /* Just a shortcut so that we don't need to call gettimeofday() */ + timeout_callback(next_timeout); + goto finish; + } - for (w = s->watches; w; w = w->watches_next) { + if (avahi_age(&next_timeout->expiry) >= 0) { - if (w->dead) - continue; + /* Timeout elapsed */ + timeout_callback(next_timeout); + goto finish; + } + } - assert(w->idx >= 0); - assert(w->idx < s->n_pollfds); + /* Look for some kind of I/O event */ + for (w = s->watches; w; w = w->watches_next) { - if (s->pollfds[w->idx].revents > 0) { - /* We execute only on callback in every iteration */ - w->callback(w, w->pollfd.fd, s->pollfds[w->idx].revents, w->userdata); - return 0; - } + if (w->dead) + continue; + + assert(w->idx >= 0); + assert(w->idx < s->n_pollfds); + + if (s->pollfds[w->idx].revents != 0) { + w->callback(w, w->pollfd.fd, s->pollfds[w->idx].revents, w->userdata); + goto finish; } } +finish: + + s->state = STATE_DISPATCHED; return 0; } -void avahi_simple_poll_quit(AvahiSimplePoll *w) { - assert(w); +int avahi_simple_poll_iterate(AvahiSimplePoll *s, int timeout) { + int r; + + if ((r = avahi_simple_poll_prepare(s, timeout)) != 0) + return r; + + if ((r = avahi_simple_poll_run(s)) != 0) + return r; - w->quit = 1; + if ((r = avahi_simple_poll_dispatch(s)) != 0) + return r; + + return 0; +} + +void avahi_simple_poll_quit(AvahiSimplePoll *s) { + assert(s); + + s->quit = 1; + + /* If there is a background thread running the poll() for us, tell it to exit the poll() */ + avahi_simple_poll_wakeup(s); } const AvahiPoll* avahi_simple_poll_get(AvahiSimplePoll *s) { assert(s); - + return &s->api; } -void avahi_simple_poll_set_func(AvahiSimplePoll *s, AvahiPollFunc func) { +static int system_poll(struct pollfd *ufds, unsigned int nfds, int timeout, AVAHI_GCC_UNUSED void *userdata) { + return poll(ufds, nfds, timeout); +} + +void avahi_simple_poll_set_func(AvahiSimplePoll *s, AvahiPollFunc func, void *userdata) { + assert(s); + + s->poll_func = func ? func : system_poll; + s->poll_func_userdata = func ? userdata : NULL; + + /* If there is a background thread running the poll() for us, tell it to exit the poll() */ + avahi_simple_poll_wakeup(s); +} + +int avahi_simple_poll_loop(AvahiSimplePoll *s) { + int r; + assert(s); - s->poll_func = func ? func : (AvahiPollFunc) poll; + for (;;) + if ((r = avahi_simple_poll_iterate(s, -1)) != 0) + if (r >= 0 || errno != EINTR) + return r; }