Home | History | Annotate | Download | only in avahi-core
      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/avahi-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 
    351