git.meshlink.io Git - catta/blob - 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 }