git.meshlink.io Git - catta/blob - avahi-common/thread-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 #include <pthread.h>
  32 #include <signal.h>
  33
  34 #include "llist.h"
  35 #include "malloc.h"
  36 #include "timeval.h"
  37 #include "simple-watch.h"
  38 #include "thread-watch.h"
  39
  40 struct AvahiThreadedPoll {
  41     AvahiSimplePoll *simple_poll;
  42     pthread_t thread_id;
  43     pthread_mutex_t mutex;
  44     int thread_running;
  45     int retval;
  46 };
  47
  48 static int poll_func(struct pollfd *ufds, unsigned int nfds, int timeout, void *userdata) {
  49     pthread_mutex_t *mutex = userdata;
  50     int r;
  51
  52     /* Before entering poll() we unlock the mutex, so that
  53      * avahi_simple_poll_quit() can succeed from another thread. */
  54
  55     pthread_mutex_unlock(mutex);
  56     r = poll(ufds, nfds, timeout);
  57     pthread_mutex_lock(mutex);
  58
  59     return r;
  60 }
  61
  62 static void* thread(void *userdata){
  63     AvahiThreadedPoll *p = userdata;
  64     sigset_t mask;
  65
  66     /* Make sure that signals are delivered to the main thread */
  67     sigfillset(&mask);
  68     pthread_sigmask(SIG_BLOCK, &mask, NULL);
  69
  70     pthread_mutex_lock(&p->mutex);
  71     p->retval = avahi_simple_poll_loop(p->simple_poll);
  72     pthread_mutex_unlock(&p->mutex);
  73
  74     return NULL;
  75 }
  76
  77 AvahiThreadedPoll *avahi_threaded_poll_new(void) {
  78     AvahiThreadedPoll *p;
  79
  80     if (!(p = avahi_new(AvahiThreadedPoll, 1)))
  81         goto fail; /* OOM */
  82
  83     if (!(p->simple_poll = avahi_simple_poll_new()))
  84         goto fail;
  85
  86     pthread_mutex_init(&p->mutex, NULL);
  87
  88     avahi_simple_poll_set_func(p->simple_poll, poll_func, &p->mutex);
  89
  90     p->thread_running = 0;
  91
  92     return p;
  93
  94 fail:
  95     if (p) {
  96         if (p->simple_poll) {
  97             avahi_simple_poll_free(p->simple_poll);
  98             pthread_mutex_destroy(&p->mutex);
  99         }
 100
 101         avahi_free(p);
 102     }
 103
 104     return NULL;
 105 }
 106
 107 void avahi_threaded_poll_free(AvahiThreadedPoll *p) {
 108     assert(p);
 109
 110     /* Make sure that this function is not called from the helper thread */
 111     assert(!p->thread_running || !pthread_equal(pthread_self(), p->thread_id));
 112
 113     if (p->thread_running)
 114         avahi_threaded_poll_stop(p);
 115
 116     if (p->simple_poll)
 117         avahi_simple_poll_free(p->simple_poll);
 118
 119     pthread_mutex_destroy(&p->mutex);
 120     avahi_free(p);
 121 }
 122
 123 const AvahiPoll* avahi_threaded_poll_get(AvahiThreadedPoll *p) {
 124     assert(p);
 125
 126     return avahi_simple_poll_get(p->simple_poll);
 127 }
 128
 129 int avahi_threaded_poll_start(AvahiThreadedPoll *p) {
 130     assert(p);
 131
 132     assert(!p->thread_running);
 133
 134     if (pthread_create(&p->thread_id, NULL, thread, p) < 0)
 135         return -1;
 136
 137     p->thread_running = 1;
 138
 139     return 0;
 140 }
 141
 142 int avahi_threaded_poll_stop(AvahiThreadedPoll *p) {
 143     assert(p);
 144
 145     if (!p->thread_running)
 146         return -1;
 147
 148     /* Make sure that this function is not called from the helper thread */
 149     assert(!pthread_equal(pthread_self(), p->thread_id));
 150
 151     pthread_mutex_lock(&p->mutex);
 152     avahi_simple_poll_quit(p->simple_poll);
 153     pthread_mutex_unlock(&p->mutex);
 154
 155     pthread_join(p->thread_id, NULL);
 156     p->thread_running = 0;
 157
 158     return p->retval;
 159 }
 160
 161 void avahi_threaded_poll_quit(AvahiThreadedPoll *p) {
 162     assert(p);
 163
 164     /* Make sure that this function is called from the helper thread */
 165     assert(pthread_equal(pthread_self(), p->thread_id));
 166
 167     avahi_simple_poll_quit(p->simple_poll);
 168 }
 169
 170 void avahi_threaded_poll_lock(AvahiThreadedPoll *p) {
 171     assert(p);
 172
 173     /* Make sure that this function is not called from the helper thread */
 174     assert(!p->thread_running || !pthread_equal(pthread_self(), p->thread_id));
 175
 176     pthread_mutex_lock(&p->mutex);
 177 }
 178
 179 void avahi_threaded_poll_unlock(AvahiThreadedPoll *p) {
 180     assert(p);
 181
 182     /* Make sure that this function is not called from the helper thread */
 183     assert(!p->thread_running || !pthread_equal(pthread_self(), p->thread_id));
 184
 185     pthread_mutex_unlock(&p->mutex);
 186 }