]> git.meshlink.io Git - catta/blob - avahi-common/simple-watch.c
watch: ignore EINTR in the main loop
[catta] / avahi-common / simple-watch.c
1 /***
2   This file is part of avahi.
3
4   avahi is free software; you can redistribute it and/or modify it
5   under the terms of the GNU Lesser General Public License as
6   published by the Free Software Foundation; either version 2.1 of the
7   License, or (at your option) any later version.
8
9   avahi is distributed in the hope that it will be useful, but WITHOUT
10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
12   Public License for more details.
13
14   You should have received a copy of the GNU Lesser General Public
15   License along with avahi; if not, write to the Free Software
16   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
17   USA.
18 ***/
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <sys/poll.h>
25 #include <assert.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <unistd.h>
29 #include <fcntl.h>
30 #include <stdio.h>
31
32 #include "llist.h"
33 #include "malloc.h"
34 #include "timeval.h"
35 #include "simple-watch.h"
36
37 struct AvahiWatch {
38     AvahiSimplePoll *simple_poll;
39     int dead;
40
41     int idx;
42     struct pollfd pollfd;
43
44     AvahiWatchCallback callback;
45     void *userdata;
46
47     AVAHI_LLIST_FIELDS(AvahiWatch, watches);
48 };
49
50 struct AvahiTimeout {
51     AvahiSimplePoll *simple_poll;
52     int dead;
53
54     int enabled;
55     struct timeval expiry;
56
57     AvahiTimeoutCallback callback;
58     void  *userdata;
59
60     AVAHI_LLIST_FIELDS(AvahiTimeout, timeouts);
61 };
62
63 struct AvahiSimplePoll {
64     AvahiPoll api;
65     AvahiPollFunc poll_func;
66     void *poll_func_userdata;
67
68     struct pollfd* pollfds;
69     int n_pollfds, max_pollfds, rebuild_pollfds;
70
71     int watch_req_cleanup, timeout_req_cleanup;
72     int quit;
73     int events_valid;
74
75     int n_watches;
76     AVAHI_LLIST_HEAD(AvahiWatch, watches);
77     AVAHI_LLIST_HEAD(AvahiTimeout, timeouts);
78
79     int wakeup_pipe[2];
80     int wakeup_issued;
81
82     int prepared_timeout;
83
84     enum {
85         STATE_INIT,
86         STATE_PREPARING,
87         STATE_PREPARED,
88         STATE_RUNNING,
89         STATE_RAN,
90         STATE_DISPATCHING,
91         STATE_DISPATCHED,
92         STATE_QUIT,
93         STATE_FAILURE
94     } state;
95 };
96
97 void avahi_simple_poll_wakeup(AvahiSimplePoll *s) {
98     char c = 'W';
99     assert(s);
100
101     write(s->wakeup_pipe[1], &c, sizeof(c));
102     s->wakeup_issued = 1;
103 }
104
105 static void clear_wakeup(AvahiSimplePoll *s) {
106     char c[10]; /* Read ten at a time */
107
108     if (!s->wakeup_issued)
109         return;
110
111     s->wakeup_issued = 0;
112
113     for(;;)
114         if (read(s->wakeup_pipe[0], &c, sizeof(c)) != sizeof(c))
115             break;
116 }
117
118 static int set_nonblock(int fd) {
119     int n;
120
121     assert(fd >= 0);
122
123     if ((n = fcntl(fd, F_GETFL)) < 0)
124         return -1;
125
126     if (n & O_NONBLOCK)
127         return 0;
128
129     return fcntl(fd, F_SETFL, n|O_NONBLOCK);
130 }
131
132 static AvahiWatch* watch_new(const AvahiPoll *api, int fd, AvahiWatchEvent event, AvahiWatchCallback callback, void *userdata) {
133     AvahiWatch *w;
134     AvahiSimplePoll *s;
135
136     assert(api);
137     assert(fd >= 0);
138     assert(callback);
139
140     s = api->userdata;
141     assert(s);
142
143     if (!(w = avahi_new(AvahiWatch, 1)))
144         return NULL;
145
146     /* If there is a background thread running the poll() for us, tell it to exit the poll() */
147     avahi_simple_poll_wakeup(s);
148
149     w->simple_poll = s;
150     w->dead = 0;
151
152     w->pollfd.fd = fd;
153     w->pollfd.events = event;
154     w->pollfd.revents = 0;
155
156     w->callback = callback;
157     w->userdata = userdata;
158
159     w->idx = -1;
160     s->rebuild_pollfds = 1;
161
162     AVAHI_LLIST_PREPEND(AvahiWatch, watches, s->watches, w);
163     s->n_watches++;
164
165     return w;
166 }
167
168 static void watch_update(AvahiWatch *w, AvahiWatchEvent events) {
169     assert(w);
170     assert(!w->dead);
171
172     /* If there is a background thread running the poll() for us, tell it to exit the poll() */
173     avahi_simple_poll_wakeup(w->simple_poll);
174
175     w->pollfd.events = events;
176
177     if (w->idx != -1) {
178         assert(w->simple_poll);
179         w->simple_poll->pollfds[w->idx] = w->pollfd;
180     } else
181         w->simple_poll->rebuild_pollfds = 1;
182 }
183
184 static AvahiWatchEvent watch_get_events(AvahiWatch *w) {
185     assert(w);
186     assert(!w->dead);
187
188     if (w->idx != -1 && w->simple_poll->events_valid)
189         return w->simple_poll->pollfds[w->idx].revents;
190
191     return 0;
192 }
193
194 static void remove_pollfd(AvahiWatch *w) {
195     assert(w);
196
197     if (w->idx == -1)
198         return;
199
200     w->simple_poll->rebuild_pollfds = 1;
201 }
202
203 static void watch_free(AvahiWatch *w) {
204     assert(w);
205
206     assert(!w->dead);
207
208     /* If there is a background thread running the poll() for us, tell it to exit the poll() */
209     avahi_simple_poll_wakeup(w->simple_poll);
210
211     remove_pollfd(w);
212
213     w->dead = 1;
214     w->simple_poll->n_watches --;
215     w->simple_poll->watch_req_cleanup = 1;
216 }
217
218 static void destroy_watch(AvahiWatch *w) {
219     assert(w);
220
221     remove_pollfd(w);
222     AVAHI_LLIST_REMOVE(AvahiWatch, watches, w->simple_poll->watches, w);
223
224     if (!w->dead)
225         w->simple_poll->n_watches --;
226
227     avahi_free(w);
228 }
229
230 static void cleanup_watches(AvahiSimplePoll *s, int all) {
231     AvahiWatch *w, *next;
232     assert(s);
233
234     for (w = s->watches; w; w = next) {
235         next = w->watches_next;
236
237         if (all || w->dead)
238             destroy_watch(w);
239     }
240
241     s->timeout_req_cleanup = 0;
242 }
243
244 static AvahiTimeout* timeout_new(const AvahiPoll *api, const struct timeval *tv, AvahiTimeoutCallback callback, void *userdata) {
245     AvahiTimeout *t;
246     AvahiSimplePoll *s;
247
248     assert(api);
249     assert(callback);
250
251     s = api->userdata;
252     assert(s);
253
254     if (!(t = avahi_new(AvahiTimeout, 1)))
255         return NULL;
256
257     /* If there is a background thread running the poll() for us, tell it to exit the poll() */
258     avahi_simple_poll_wakeup(s);
259
260     t->simple_poll = s;
261     t->dead = 0;
262
263     if ((t->enabled = !!tv))
264         t->expiry = *tv;
265
266     t->callback = callback;
267     t->userdata = userdata;
268
269     AVAHI_LLIST_PREPEND(AvahiTimeout, timeouts, s->timeouts, t);
270     return t;
271 }
272
273 static void timeout_update(AvahiTimeout *t, const struct timeval *tv) {
274     assert(t);
275     assert(!t->dead);
276
277     /* If there is a background thread running the poll() for us, tell it to exit the poll() */
278     avahi_simple_poll_wakeup(t->simple_poll);
279
280     if ((t->enabled = !!tv))
281         t->expiry = *tv;
282 }
283
284 static void timeout_free(AvahiTimeout *t) {
285     assert(t);
286     assert(!t->dead);
287
288     /* If there is a background thread running the poll() for us, tell it to exit the poll() */
289     avahi_simple_poll_wakeup(t->simple_poll);
290
291     t->dead = 1;
292     t->simple_poll->timeout_req_cleanup = 1;
293 }
294
295
296 static void destroy_timeout(AvahiTimeout *t) {
297     assert(t);
298
299     AVAHI_LLIST_REMOVE(AvahiTimeout, timeouts, t->simple_poll->timeouts, t);
300
301     avahi_free(t);
302 }
303
304 static void cleanup_timeouts(AvahiSimplePoll *s, int all) {
305     AvahiTimeout *t, *next;
306     assert(s);
307
308     for (t = s->timeouts; t; t = next) {
309         next = t->timeouts_next;
310
311         if (all || t->dead)
312             destroy_timeout(t);
313     }
314
315     s->timeout_req_cleanup = 0;
316 }
317
318 AvahiSimplePoll *avahi_simple_poll_new(void) {
319     AvahiSimplePoll *s;
320
321     if (!(s = avahi_new(AvahiSimplePoll, 1)))
322         return NULL;
323
324     if (pipe(s->wakeup_pipe) < 0) {
325         avahi_free(s);
326         return NULL;
327     }
328
329     set_nonblock(s->wakeup_pipe[0]);
330     set_nonblock(s->wakeup_pipe[1]);
331
332     s->api.userdata = s;
333
334     s->api.watch_new = watch_new;
335     s->api.watch_free = watch_free;
336     s->api.watch_update = watch_update;
337     s->api.watch_get_events = watch_get_events;
338
339     s->api.timeout_new = timeout_new;
340     s->api.timeout_free = timeout_free;
341     s->api.timeout_update = timeout_update;
342
343     s->pollfds = NULL;
344     s->max_pollfds = s->n_pollfds = 0;
345     s->rebuild_pollfds = 1;
346     s->quit = 0;
347     s->n_watches = 0;
348     s->events_valid = 0;
349
350     s->watch_req_cleanup = 0;
351     s->timeout_req_cleanup = 0;
352
353     s->prepared_timeout = 0;
354
355     s->state = STATE_INIT;
356
357     s->wakeup_issued = 0;
358
359     avahi_simple_poll_set_func(s, NULL, NULL);
360
361     AVAHI_LLIST_HEAD_INIT(AvahiWatch, s->watches);
362     AVAHI_LLIST_HEAD_INIT(AvahiTimeout, s->timeouts);
363
364     return s;
365 }
366
367 void avahi_simple_poll_free(AvahiSimplePoll *s) {
368     assert(s);
369
370     cleanup_timeouts(s, 1);
371     cleanup_watches(s, 1);
372     assert(s->n_watches == 0);
373
374     avahi_free(s->pollfds);
375
376     if (s->wakeup_pipe[0] >= 0)
377         close(s->wakeup_pipe[0]);
378
379     if (s->wakeup_pipe[1] >= 0)
380         close(s->wakeup_pipe[1]);
381
382     avahi_free(s);
383 }
384
385 static int rebuild(AvahiSimplePoll *s) {
386     AvahiWatch *w;
387     int idx;
388
389     assert(s);
390
391     if (s->n_watches+1 > s->max_pollfds) {
392         struct pollfd *n;
393
394         s->max_pollfds = s->n_watches + 10;
395
396         if (!(n = avahi_realloc(s->pollfds, sizeof(struct pollfd) * s->max_pollfds)))
397             return -1;
398
399         s->pollfds = n;
400     }
401
402
403     s->pollfds[0].fd = s->wakeup_pipe[0];
404     s->pollfds[0].events = POLLIN;
405     s->pollfds[0].revents = 0;
406
407     idx = 1;
408
409     for (w = s->watches; w; w = w->watches_next) {
410
411         if(w->dead)
412             continue;
413
414         assert(w->idx < s->max_pollfds);
415         s->pollfds[w->idx = idx++] = w->pollfd;
416     }
417
418     s->n_pollfds = idx;
419     s->events_valid = 0;
420     s->rebuild_pollfds = 0;
421
422     return 0;
423 }
424
425 static AvahiTimeout* find_next_timeout(AvahiSimplePoll *s) {
426     AvahiTimeout *t, *n = NULL;
427     assert(s);
428
429     for (t = s->timeouts; t; t = t->timeouts_next) {
430
431         if (t->dead || !t->enabled)
432             continue;
433
434         if (!n || avahi_timeval_compare(&t->expiry, &n->expiry) < 0)
435             n = t;
436     }
437
438     return n;
439 }
440
441 static void timeout_callback(AvahiTimeout *t) {
442     assert(t);
443     assert(!t->dead);
444     assert(t->enabled);
445
446     t->enabled = 0;
447     t->callback(t, t->userdata);
448 }
449
450 int avahi_simple_poll_prepare(AvahiSimplePoll *s, int timeout) {
451     AvahiTimeout *next_timeout;
452
453     assert(s);
454     assert(s->state == STATE_INIT || s->state == STATE_DISPATCHED || s->state == STATE_FAILURE);
455     s->state = STATE_PREPARING;
456
457     /* Clear pending wakeup requests */
458     clear_wakeup(s);
459
460     /* Cleanup things first */
461     if (s->watch_req_cleanup)
462         cleanup_watches(s, 0);
463
464     if (s->timeout_req_cleanup)
465         cleanup_timeouts(s, 0);
466
467     /* Check whether a quit was requested */
468     if (s->quit) {
469         s->state = STATE_QUIT;
470         return 1;
471     }
472
473     /* Do we need to rebuild our array of pollfds? */
474     if (s->rebuild_pollfds)
475         if (rebuild(s) < 0) {
476             s->state = STATE_FAILURE;
477             return -1;
478         }
479
480     /* Calculate the wakeup time */
481     if ((next_timeout = find_next_timeout(s))) {
482         struct timeval now;
483         int t;
484         AvahiUsec usec;
485
486         if (next_timeout->expiry.tv_sec == 0 &&
487             next_timeout->expiry.tv_usec == 0) {
488
489             /* Just a shortcut so that we don't need to call gettimeofday() */
490             timeout = 0;
491             goto finish;
492         }
493
494         gettimeofday(&now, NULL);
495         usec = avahi_timeval_diff(&next_timeout->expiry, &now);
496
497         if (usec <= 0) {
498             /* Timeout elapsed */
499
500             timeout = 0;
501             goto finish;
502         }
503
504         /* Calculate sleep time. We add 1ms because otherwise we'd
505          * wake up too early most of the time */
506         t = (int) (usec / 1000) + 1;
507
508         if (timeout < 0 || timeout > t)
509             timeout = t;
510     }
511
512 finish:
513     s->prepared_timeout = timeout;
514     s->state = STATE_PREPARED;
515     return 0;
516 }
517
518 int avahi_simple_poll_run(AvahiSimplePoll *s) {
519     assert(s);
520     assert(s->state == STATE_PREPARED || s->state == STATE_FAILURE);
521
522     s->state = STATE_RUNNING;
523
524     for (;;) {
525         errno = 0;
526
527         if (s->poll_func(s->pollfds, s->n_pollfds, s->prepared_timeout, s->poll_func_userdata) < 0) {
528
529             if (errno == EINTR)
530                 continue;
531
532             s->state = STATE_FAILURE;
533             return -1;
534         }
535
536         break;
537     }
538
539     /* The poll events are now valid again */
540     s->events_valid = 1;
541
542     /* Update state */
543     s->state = STATE_RAN;
544     return 0;
545 }
546
547 int avahi_simple_poll_dispatch(AvahiSimplePoll *s) {
548     AvahiTimeout *next_timeout;
549     AvahiWatch *w;
550
551     assert(s);
552     assert(s->state == STATE_RAN);
553     s->state = STATE_DISPATCHING;
554
555     /* We execute only on callback in every iteration */
556
557     /* Check whether the wakeup time has been reached now */
558     if ((next_timeout = find_next_timeout(s))) {
559
560         if (next_timeout->expiry.tv_sec == 0 && next_timeout->expiry.tv_usec == 0) {
561
562             /* Just a shortcut so that we don't need to call gettimeofday() */
563             timeout_callback(next_timeout);
564             goto finish;
565         }
566
567         if (avahi_age(&next_timeout->expiry) >= 0) {
568
569             /* Timeout elapsed */
570             timeout_callback(next_timeout);
571             goto finish;
572         }
573     }
574
575     /* Look for some kind of I/O event */
576     for (w = s->watches; w; w = w->watches_next) {
577
578         if (w->dead)
579             continue;
580
581         assert(w->idx >= 0);
582         assert(w->idx < s->n_pollfds);
583
584         if (s->pollfds[w->idx].revents != 0) {
585             w->callback(w, w->pollfd.fd, s->pollfds[w->idx].revents, w->userdata);
586             goto finish;
587         }
588     }
589
590 finish:
591
592     s->state = STATE_DISPATCHED;
593     return 0;
594 }
595
596 int avahi_simple_poll_iterate(AvahiSimplePoll *s, int timeout) {
597     int r;
598
599     if ((r = avahi_simple_poll_prepare(s, timeout)) != 0)
600         return r;
601
602     if ((r = avahi_simple_poll_run(s)) != 0)
603         return r;
604
605     if ((r = avahi_simple_poll_dispatch(s)) != 0)
606         return r;
607
608     return 0;
609 }
610
611 void avahi_simple_poll_quit(AvahiSimplePoll *s) {
612     assert(s);
613
614     s->quit = 1;
615
616     /* If there is a background thread running the poll() for us, tell it to exit the poll() */
617     avahi_simple_poll_wakeup(s);
618 }
619
620 const AvahiPoll* avahi_simple_poll_get(AvahiSimplePoll *s) {
621     assert(s);
622
623     return &s->api;
624 }
625
626 static int system_poll(struct pollfd *ufds, unsigned int nfds, int timeout, AVAHI_GCC_UNUSED void *userdata) {
627     return poll(ufds, nfds, timeout);
628 }
629
630 void avahi_simple_poll_set_func(AvahiSimplePoll *s, AvahiPollFunc func, void *userdata) {
631     assert(s);
632
633     s->poll_func = func ? func : system_poll;
634     s->poll_func_userdata = func ? userdata : NULL;
635
636     /* If there is a background thread running the poll() for us, tell it to exit the poll() */
637     avahi_simple_poll_wakeup(s);
638 }
639
640 int avahi_simple_poll_loop(AvahiSimplePoll *s) {
641     int r;
642
643     assert(s);
644
645     for (;;)
646         if ((r = avahi_simple_poll_iterate(s, -1)) != 0)
647             if (r >= 0 || errno != EINTR)
648                 return r;
649 }