git.meshlink.io Git - catta/blob - avahi-core/multicast-lookup.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 <stdlib.h>
  25
  26 #include <avahi-common/malloc.h>
  27 #include <avahi-common/timeval.h>
  28
  29 #include "internal.h"
  30 #include "browse.h"
  31 #include "socket.h"
  32 #include "log.h"
  33 #include "hashmap.h"
  34 #include "multicast-lookup.h"
  35 #include "rr-util.h"
  36
  37 struct AvahiMulticastLookup {
  38     AvahiMulticastLookupEngine *engine;
  39     int dead;
  40
  41     AvahiKey *key, *cname_key;
  42
  43     AvahiMulticastLookupCallback callback;
  44     void *userdata;
  45
  46     AvahiIfIndex interface;
  47     AvahiProtocol protocol;
  48
  49     int queriers_added;
  50
  51     AvahiTimeEvent *all_for_now_event;
  52
  53     AVAHI_LLIST_FIELDS(AvahiMulticastLookup, lookups);
  54     AVAHI_LLIST_FIELDS(AvahiMulticastLookup, by_key);
  55 };
  56
  57 struct AvahiMulticastLookupEngine {
  58     AvahiServer *server;
  59
  60     /* Lookups */
  61     AVAHI_LLIST_HEAD(AvahiMulticastLookup, lookups);
  62     AvahiHashmap *lookups_by_key;
  63
  64     int cleanup_dead;
  65 };
  66
  67 static void all_for_now_callback(AvahiTimeEvent *e, void* userdata) {
  68     AvahiMulticastLookup *l = userdata;
  69
  70     assert(e);
  71     assert(l);
  72
  73     avahi_time_event_free(l->all_for_now_event);
  74     l->all_for_now_event = NULL;
  75
  76     l->callback(l->engine, l->interface, l->protocol, AVAHI_BROWSER_ALL_FOR_NOW, AVAHI_LOOKUP_RESULT_MULTICAST, NULL, l->userdata);
  77 }
  78
  79 AvahiMulticastLookup *avahi_multicast_lookup_new(
  80     AvahiMulticastLookupEngine *e,
  81     AvahiIfIndex interface,
  82     AvahiProtocol protocol,
  83     AvahiKey *key,
  84     AvahiMulticastLookupCallback callback,
  85     void *userdata) {
  86
  87     AvahiMulticastLookup *l, *t;
  88     struct timeval tv;
  89
  90     assert(e);
  91     assert(AVAHI_IF_VALID(interface));
  92     assert(AVAHI_PROTO_VALID(protocol));
  93     assert(key);
  94     assert(callback);
  95
  96     l = avahi_new(AvahiMulticastLookup, 1);
  97     l->engine = e;
  98     l->dead = 0;
  99     l->key = avahi_key_ref(key);
 100     l->cname_key = avahi_key_new_cname(l->key);
 101     l->callback = callback;
 102     l->userdata = userdata;
 103     l->interface = interface;
 104     l->protocol = protocol;
 105     l->all_for_now_event = NULL;
 106     l->queriers_added = 0;
 107
 108     t = avahi_hashmap_lookup(e->lookups_by_key, l->key);
 109     AVAHI_LLIST_PREPEND(AvahiMulticastLookup, by_key, t, l);
 110     avahi_hashmap_replace(e->lookups_by_key, avahi_key_ref(l->key), t);
 111
 112     AVAHI_LLIST_PREPEND(AvahiMulticastLookup, lookups, e->lookups, l);
 113
 114     avahi_querier_add_for_all(e->server, interface, protocol, l->key, &tv);
 115     l->queriers_added = 1;
 116
 117     /* Add a second */
 118     avahi_timeval_add(&tv, 1000000);
 119
 120     /* Issue the ALL_FOR_NOW event one second after the querier was initially created */
 121     l->all_for_now_event = avahi_time_event_new(e->server->time_event_queue, &tv, all_for_now_callback, l);
 122
 123     return l;
 124 }
 125
 126 static void lookup_stop(AvahiMulticastLookup *l) {
 127     assert(l);
 128
 129     l->callback = NULL;
 130
 131     if (l->queriers_added) {
 132         avahi_querier_remove_for_all(l->engine->server, l->interface, l->protocol, l->key);
 133         l->queriers_added = 0;
 134     }
 135
 136     if (l->all_for_now_event) {
 137         avahi_time_event_free(l->all_for_now_event);
 138         l->all_for_now_event = NULL;
 139     }
 140 }
 141
 142 static void lookup_destroy(AvahiMulticastLookup *l) {
 143     AvahiMulticastLookup *t;
 144     assert(l);
 145
 146     lookup_stop(l);
 147
 148     t = avahi_hashmap_lookup(l->engine->lookups_by_key, l->key);
 149     AVAHI_LLIST_REMOVE(AvahiMulticastLookup, by_key, t, l);
 150     if (t)
 151         avahi_hashmap_replace(l->engine->lookups_by_key, avahi_key_ref(l->key), t);
 152     else
 153         avahi_hashmap_remove(l->engine->lookups_by_key, l->key);
 154
 155     AVAHI_LLIST_REMOVE(AvahiMulticastLookup, lookups, l->engine->lookups, l);
 156
 157     if (l->key)
 158         avahi_key_unref(l->key);
 159
 160     if (l->cname_key)
 161         avahi_key_unref(l->cname_key);
 162
 163     avahi_free(l);
 164 }
 165
 166 void avahi_multicast_lookup_free(AvahiMulticastLookup *l) {
 167     assert(l);
 168
 169     if (l->dead)
 170         return;
 171
 172     l->dead = 1;
 173     l->engine->cleanup_dead = 1;
 174     lookup_stop(l);
 175 }
 176
 177 void avahi_multicast_lookup_engine_cleanup(AvahiMulticastLookupEngine *e) {
 178     AvahiMulticastLookup *l, *n;
 179     assert(e);
 180
 181     while (e->cleanup_dead) {
 182         e->cleanup_dead = 0;
 183
 184         for (l = e->lookups; l; l = n) {
 185             n = l->lookups_next;
 186
 187             if (l->dead)
 188                 lookup_destroy(l);
 189         }
 190     }
 191 }
 192
 193 struct cbdata {
 194     AvahiMulticastLookupEngine *engine;
 195     AvahiMulticastLookupCallback callback;
 196     void *userdata;
 197     AvahiKey *key, *cname_key;
 198     AvahiInterface *interface;
 199     unsigned n_found;
 200 };
 201
 202 static void* scan_cache_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void* userdata) {
 203     struct cbdata *cbdata = userdata;
 204
 205     assert(c);
 206     assert(pattern);
 207     assert(e);
 208     assert(cbdata);
 209
 210     cbdata->callback(
 211         cbdata->engine,
 212         cbdata->interface->hardware->index,
 213         cbdata->interface->protocol,
 214         AVAHI_BROWSER_NEW,
 215         AVAHI_LOOKUP_RESULT_CACHED|AVAHI_LOOKUP_RESULT_MULTICAST,
 216         e->record,
 217         cbdata->userdata);
 218
 219     cbdata->n_found ++;
 220
 221     return NULL;
 222 }
 223
 224 static void scan_interface_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) {
 225     struct cbdata *cbdata = userdata;
 226
 227     assert(m);
 228     assert(i);
 229     assert(cbdata);
 230
 231     cbdata->interface = i;
 232
 233     avahi_cache_walk(i->cache, cbdata->key, scan_cache_callback, cbdata);
 234
 235     if (cbdata->cname_key)
 236         avahi_cache_walk(i->cache, cbdata->cname_key, scan_cache_callback, cbdata);
 237
 238     cbdata->interface = NULL;
 239 }
 240
 241 unsigned avahi_multicast_lookup_engine_scan_cache(
 242     AvahiMulticastLookupEngine *e,
 243     AvahiIfIndex interface,
 244     AvahiProtocol protocol,
 245     AvahiKey *key,
 246     AvahiMulticastLookupCallback callback,
 247     void *userdata) {
 248
 249     struct cbdata cbdata;
 250
 251     assert(e);
 252     assert(key);
 253     assert(callback);
 254
 255     assert(AVAHI_IF_VALID(interface));
 256     assert(AVAHI_PROTO_VALID(protocol));
 257
 258     cbdata.engine = e;
 259     cbdata.key = key;
 260     cbdata.cname_key = avahi_key_new_cname(key);
 261     cbdata.callback = callback;
 262     cbdata.userdata = userdata;
 263     cbdata.interface = NULL;
 264     cbdata.n_found = 0;
 265
 266     avahi_interface_monitor_walk(e->server->monitor, interface, protocol, scan_interface_callback, &cbdata);
 267
 268     if (cbdata.cname_key)
 269         avahi_key_unref(cbdata.cname_key);
 270
 271     return cbdata.n_found;
 272 }
 273
 274 void avahi_multicast_lookup_engine_new_interface(AvahiMulticastLookupEngine *e, AvahiInterface *i) {
 275     AvahiMulticastLookup *l;
 276
 277     assert(e);
 278     assert(i);
 279
 280     for (l = e->lookups; l; l = l->lookups_next) {
 281
 282         if (l->dead || !l->callback)
 283             continue;
 284
 285         if (l->queriers_added && avahi_interface_match(i, l->interface, l->protocol))
 286             avahi_querier_add(i, l->key, NULL);
 287     }
 288 }
 289
 290 void avahi_multicast_lookup_engine_notify(AvahiMulticastLookupEngine *e, AvahiInterface *i, AvahiRecord *record, AvahiBrowserEvent event) {
 291     AvahiMulticastLookup *l;
 292
 293     assert(e);
 294     assert(record);
 295     assert(i);
 296
 297     for (l = avahi_hashmap_lookup(e->lookups_by_key, record->key); l; l = l->by_key_next) {
 298         if (l->dead || !l->callback)
 299             continue;
 300
 301         if (avahi_interface_match(i, l->interface, l->protocol))
 302             l->callback(e, i->hardware->index, i->protocol, event, AVAHI_LOOKUP_RESULT_MULTICAST, record, l->userdata);
 303     }
 304
 305
 306     if (record->key->clazz == AVAHI_DNS_CLASS_IN && record->key->type == AVAHI_DNS_TYPE_CNAME) {
 307         /* It's a CNAME record, so we have to scan the all lookups to see if one matches */
 308
 309         for (l = e->lookups; l; l = l->lookups_next) {
 310             AvahiKey *key;
 311
 312             if (l->dead || !l->callback)
 313                 continue;
 314
 315             if ((key = avahi_key_new_cname(l->key))) {
 316                 if (avahi_key_equal(record->key, key))
 317                     l->callback(e, i->hardware->index, i->protocol, event, AVAHI_LOOKUP_RESULT_MULTICAST, record, l->userdata);
 318
 319                 avahi_key_unref(key);
 320             }
 321         }
 322     }
 323 }
 324
 325 AvahiMulticastLookupEngine *avahi_multicast_lookup_engine_new(AvahiServer *s) {
 326     AvahiMulticastLookupEngine *e;
 327
 328     assert(s);
 329
 330     e = avahi_new(AvahiMulticastLookupEngine, 1);
 331     e->server = s;
 332     e->cleanup_dead = 0;
 333
 334     /* Initialize lookup list */
 335     e->lookups_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, (AvahiFreeFunc) avahi_key_unref, NULL);
 336     AVAHI_LLIST_HEAD_INIT(AvahiWideAreaLookup, e->lookups);
 337
 338     return e;
 339 }
 340
 341 void avahi_multicast_lookup_engine_free(AvahiMulticastLookupEngine *e) {
 342     assert(e);
 343
 344     while (e->lookups)
 345         lookup_destroy(e->lookups);
 346
 347     avahi_hashmap_free(e->lookups_by_key);
 348     avahi_free(e);
 349 }
 350