git.meshlink.io Git - catta/blob - avahi-common/dbus-watch-glue.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 <assert.h>
  25 #include <stdio.h>
  26
  27 #include "malloc.h"
  28 #include "timeval.h"
  29 #include "dbus-watch-glue.h"
  30
  31 static AvahiWatchEvent translate_dbus_to_avahi(unsigned int f) {
  32     AvahiWatchEvent e = 0;
  33
  34     if (f & DBUS_WATCH_READABLE)
  35         e |= AVAHI_WATCH_IN;
  36     if (f & DBUS_WATCH_WRITABLE)
  37         e |= AVAHI_WATCH_OUT;
  38     if (f & DBUS_WATCH_ERROR)
  39         e |= AVAHI_WATCH_ERR;
  40     if (f & DBUS_WATCH_HANGUP)
  41         e |= AVAHI_WATCH_HUP;
  42
  43     return e;
  44 }
  45
  46 static unsigned int translate_avahi_to_dbus(AvahiWatchEvent e) {
  47     unsigned int f = 0;
  48
  49     if (e & AVAHI_WATCH_IN)
  50         f |= DBUS_WATCH_READABLE;
  51     if (e & AVAHI_WATCH_OUT)
  52         f |= DBUS_WATCH_WRITABLE;
  53     if (e & AVAHI_WATCH_ERR)
  54         f |= DBUS_WATCH_ERROR;
  55     if (e & AVAHI_WATCH_HUP)
  56         f |= DBUS_WATCH_HANGUP;
  57
  58     return f;
  59 }
  60
  61 typedef struct {
  62     DBusConnection *connection;
  63     const AvahiPoll *poll_api;
  64     AvahiTimeout *dispatch_timeout;
  65     int ref;
  66 } ConnectionData;
  67
  68 static ConnectionData *connection_data_ref(ConnectionData *d) {
  69     assert(d);
  70     assert(d->ref >= 1);
  71
  72     d->ref++;
  73     return d;
  74 }
  75
  76 static void connection_data_unref(ConnectionData *d) {
  77     assert(d);
  78     assert(d->ref >= 1);
  79
  80     if (--d->ref <= 0) {
  81         d->poll_api->timeout_free(d->dispatch_timeout);
  82         avahi_free(d);
  83     }
  84 }
  85
  86 static void request_dispatch(ConnectionData *d, int enable) {
  87     static const struct timeval tv = { 0, 0 };
  88     assert(d);
  89
  90     if (enable) {
  91         assert(dbus_connection_get_dispatch_status(d->connection) == DBUS_DISPATCH_DATA_REMAINS);
  92         d->poll_api->timeout_update(d->dispatch_timeout, &tv);
  93     } else
  94         d->poll_api->timeout_update(d->dispatch_timeout, NULL);
  95 }
  96
  97 static void dispatch_timeout_callback(AvahiTimeout *t, void *userdata) {
  98     ConnectionData *d = userdata;
  99     assert(t);
 100     assert(d);
 101
 102     connection_data_ref(d);
 103     dbus_connection_ref(d->connection);
 104
 105     if (dbus_connection_dispatch(d->connection) == DBUS_DISPATCH_DATA_REMAINS)
 106         /* If there's still data, request that this handler is called again */
 107         request_dispatch(d, 1);
 108     else
 109         request_dispatch(d, 0);
 110
 111     dbus_connection_unref(d->connection);
 112     connection_data_unref(d);
 113 }
 114
 115 static void watch_callback(AvahiWatch *avahi_watch, AVAHI_GCC_UNUSED int fd, AvahiWatchEvent events, void *userdata) {
 116     DBusWatch *dbus_watch = userdata;
 117
 118     assert(avahi_watch);
 119     assert(dbus_watch);
 120
 121     dbus_watch_handle(dbus_watch, translate_avahi_to_dbus(events));
 122     /* Ignore the return value */
 123 }
 124
 125 static dbus_bool_t update_watch(const AvahiPoll *poll_api, DBusWatch *dbus_watch) {
 126     AvahiWatch *avahi_watch;
 127     dbus_bool_t b;
 128
 129     assert(dbus_watch);
 130
 131     avahi_watch = dbus_watch_get_data(dbus_watch);
 132
 133     b = dbus_watch_get_enabled(dbus_watch);
 134
 135     if (b && !avahi_watch) {
 136
 137         if (!(avahi_watch = poll_api->watch_new(
 138                   poll_api,
 139 #if (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR == 1 && DBUS_VERSION_MICRO >= 1) || (DBUS_VERSION_MAJOR == 1 && DBUS_VERSION_MINOR > 1) || (DBUS_VERSION_MAJOR > 1)
 140                   dbus_watch_get_unix_fd(dbus_watch),
 141 #else
 142                   dbus_watch_get_fd(dbus_watch),
 143 #endif
 144                   translate_dbus_to_avahi(dbus_watch_get_flags(dbus_watch)),
 145                   watch_callback,
 146                   dbus_watch)))
 147             return FALSE;
 148
 149         dbus_watch_set_data(dbus_watch, avahi_watch, NULL);
 150
 151     } else if (!b && avahi_watch) {
 152
 153         poll_api->watch_free(avahi_watch);
 154         dbus_watch_set_data(dbus_watch, NULL, NULL);
 155
 156     } else if (avahi_watch) {
 157
 158         /* Update flags */
 159         poll_api->watch_update(avahi_watch, dbus_watch_get_flags(dbus_watch));
 160     }
 161
 162     return TRUE;
 163 }
 164
 165 static dbus_bool_t add_watch(DBusWatch *dbus_watch, void *userdata) {
 166     ConnectionData *d = userdata;
 167
 168     assert(dbus_watch);
 169     assert(d);
 170
 171     return update_watch(d->poll_api, dbus_watch);
 172 }
 173
 174 static void remove_watch(DBusWatch *dbus_watch, void *userdata) {
 175     ConnectionData *d = userdata;
 176     AvahiWatch *avahi_watch;
 177
 178     assert(dbus_watch);
 179     assert(d);
 180
 181     if ((avahi_watch = dbus_watch_get_data(dbus_watch))) {
 182         d->poll_api->watch_free(avahi_watch);
 183         dbus_watch_set_data(dbus_watch, NULL, NULL);
 184     }
 185 }
 186
 187 static void watch_toggled(DBusWatch *dbus_watch, void *userdata) {
 188     ConnectionData *d = userdata;
 189
 190     assert(dbus_watch);
 191     assert(d);
 192
 193     update_watch(d->poll_api, dbus_watch);
 194 }
 195
 196 typedef struct TimeoutData {
 197     const AvahiPoll *poll_api;
 198     AvahiTimeout *avahi_timeout;
 199     DBusTimeout *dbus_timeout;
 200     int ref;
 201 } TimeoutData;
 202
 203 static TimeoutData* timeout_data_ref(TimeoutData *t) {
 204     assert(t);
 205     assert(t->ref >= 1);
 206
 207     t->ref++;
 208     return t;
 209 }
 210
 211 static void timeout_data_unref(TimeoutData *t) {
 212     assert(t);
 213     assert(t->ref >= 1);
 214
 215     if (--t->ref <= 0) {
 216         if (t->avahi_timeout)
 217             t->poll_api->timeout_free(t->avahi_timeout);
 218
 219         avahi_free(t);
 220     }
 221 }
 222
 223 static void update_timeout(TimeoutData *timeout) {
 224     assert(timeout);
 225     assert(timeout->ref >= 1);
 226
 227     if (dbus_timeout_get_enabled(timeout->dbus_timeout)) {
 228         struct timeval tv;
 229         avahi_elapse_time(&tv, dbus_timeout_get_interval(timeout->dbus_timeout), 0);
 230         timeout->poll_api->timeout_update(timeout->
 231                                       avahi_timeout, &tv);
 232     } else
 233         timeout->poll_api->timeout_update(timeout->avahi_timeout, NULL);
 234
 235 }
 236
 237 static void timeout_callback(AvahiTimeout *avahi_timeout, void *userdata) {
 238     TimeoutData *timeout = userdata;
 239
 240     assert(avahi_timeout);
 241     assert(timeout);
 242
 243     timeout_data_ref(timeout);
 244
 245     dbus_timeout_handle(timeout->dbus_timeout);
 246     /* Ignore the return value */
 247
 248     if (timeout->avahi_timeout)
 249         update_timeout(timeout);
 250
 251     timeout_data_unref(timeout);
 252 }
 253
 254 static dbus_bool_t add_timeout(DBusTimeout *dbus_timeout, void *userdata) {
 255     TimeoutData *timeout;
 256     ConnectionData *d = userdata;
 257     struct timeval tv;
 258     dbus_bool_t b;
 259
 260     assert(dbus_timeout);
 261     assert(d);
 262
 263     if (!(timeout = avahi_new(TimeoutData, 1)))
 264         return FALSE;
 265
 266     timeout->dbus_timeout = dbus_timeout;
 267     timeout->poll_api = d->poll_api;
 268     timeout->ref = 1;
 269
 270     if ((b = dbus_timeout_get_enabled(dbus_timeout)))
 271         avahi_elapse_time(&tv, dbus_timeout_get_interval(dbus_timeout), 0);
 272
 273     if (!(timeout->avahi_timeout = d->poll_api->timeout_new(
 274               d->poll_api,
 275               b ? &tv : NULL,
 276               timeout_callback,
 277               timeout))) {
 278         avahi_free(timeout);
 279         return FALSE;
 280     }
 281
 282     dbus_timeout_set_data(dbus_timeout, timeout, (DBusFreeFunction) timeout_data_unref);
 283     return TRUE;
 284 }
 285
 286 static void remove_timeout(DBusTimeout *dbus_timeout, void *userdata) {
 287     ConnectionData *d = userdata;
 288     TimeoutData *timeout;
 289
 290     assert(dbus_timeout);
 291     assert(d);
 292
 293     timeout = dbus_timeout_get_data(dbus_timeout);
 294     assert(timeout);
 295
 296     d->poll_api->timeout_free(timeout->avahi_timeout);
 297     timeout->avahi_timeout = NULL;
 298 }
 299
 300 static void timeout_toggled(DBusTimeout *dbus_timeout, AVAHI_GCC_UNUSED void *userdata) {
 301     TimeoutData *timeout;
 302
 303     assert(dbus_timeout);
 304     timeout = dbus_timeout_get_data(dbus_timeout);
 305     assert(timeout);
 306
 307     update_timeout(timeout);
 308 }
 309
 310 static void dispatch_status(AVAHI_GCC_UNUSED DBusConnection *connection, DBusDispatchStatus new_status, void *userdata) {
 311     ConnectionData *d = userdata;
 312
 313     if (new_status == DBUS_DISPATCH_DATA_REMAINS)
 314         request_dispatch(d, 1);
 315  }
 316
 317 int avahi_dbus_connection_glue(DBusConnection *c, const AvahiPoll *poll_api) {
 318     ConnectionData *d = NULL;
 319
 320     assert(c);
 321     assert(poll_api);
 322
 323     if (!(d = avahi_new(ConnectionData, 1)))
 324         goto fail;;
 325
 326     d->poll_api = poll_api;
 327     d->connection = c;
 328     d->ref = 1;
 329
 330     if (!(d->dispatch_timeout = poll_api->timeout_new(poll_api, NULL, dispatch_timeout_callback, d)))
 331         goto fail;
 332
 333     if (!(dbus_connection_set_watch_functions(c, add_watch, remove_watch, watch_toggled, connection_data_ref(d), (DBusFreeFunction)connection_data_unref)))
 334         goto fail;
 335
 336     if (!(dbus_connection_set_timeout_functions(c, add_timeout, remove_timeout, timeout_toggled, connection_data_ref(d), (DBusFreeFunction)connection_data_unref)))
 337         goto fail;
 338
 339     dbus_connection_set_dispatch_status_function(c, dispatch_status, connection_data_ref(d), (DBusFreeFunction)connection_data_unref);
 340
 341     if (dbus_connection_get_dispatch_status(c) == DBUS_DISPATCH_DATA_REMAINS)
 342         request_dispatch(d, 1);
 343
 344     connection_data_unref(d);
 345
 346     return 0;
 347
 348 fail:
 349
 350     if (d) {
 351         d->poll_api->timeout_free(d->dispatch_timeout);
 352
 353         avahi_free(d);
 354     }
 355
 356     return -1;
 357 }