git.meshlink.io Git - catta/blob - avahi-core/wide-area.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   6   avahi is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   avahi is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  14   Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with avahi; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30 #include <netinet/in.h>
  31
  32 #include <avahi-common/malloc.h>
  33 #include <avahi-common/error.h>
  34 #include <avahi-common/timeval.h>
  35
  36 #include "internal.h"
  37 #include "browse.h"
  38 #include "socket.h"
  39 #include "log.h"
  40 #include "hashmap.h"
  41 #include "wide-area.h"
  42 #include "addr-util.h"
  43 #include "rr-util.h"
  44
  45 #define CACHE_ENTRIES_MAX 500
  46
  47 typedef struct AvahiWideAreaCacheEntry AvahiWideAreaCacheEntry;
  48
  49 struct AvahiWideAreaCacheEntry {
  50     AvahiWideAreaLookupEngine *engine;
  51
  52     AvahiRecord *record;
  53     struct timeval timestamp;
  54     struct timeval expiry;
  55
  56     AvahiTimeEvent *time_event;
  57
  58     AVAHI_LLIST_FIELDS(AvahiWideAreaCacheEntry, by_key);
  59     AVAHI_LLIST_FIELDS(AvahiWideAreaCacheEntry, cache);
  60 };
  61
  62 struct AvahiWideAreaLookup {
  63     AvahiWideAreaLookupEngine *engine;
  64     int dead;
  65
  66     uint32_t id;  /* effectively just an uint16_t, but we need it as an index for a hash table */
  67     AvahiTimeEvent *time_event;
  68
  69     AvahiKey *key, *cname_key;
  70
  71     int n_send;
  72     AvahiDnsPacket *packet;
  73
  74     AvahiWideAreaLookupCallback callback;
  75     void *userdata;
  76
  77     AvahiAddress dns_server_used;
  78
  79     AVAHI_LLIST_FIELDS(AvahiWideAreaLookup, lookups);
  80     AVAHI_LLIST_FIELDS(AvahiWideAreaLookup, by_key);
  81 };
  82
  83 struct AvahiWideAreaLookupEngine {
  84     AvahiServer *server;
  85
  86     int fd_ipv4, fd_ipv6;
  87     AvahiWatch *watch_ipv4, *watch_ipv6;
  88
  89     uint16_t next_id;
  90
  91     /* Cache */
  92     AVAHI_LLIST_HEAD(AvahiWideAreaCacheEntry, cache);
  93     AvahiHashmap *cache_by_key;
  94     unsigned cache_n_entries;
  95
  96     /* Lookups */
  97     AVAHI_LLIST_HEAD(AvahiWideAreaLookup, lookups);
  98     AvahiHashmap *lookups_by_id;
  99     AvahiHashmap *lookups_by_key;
 100
 101     int cleanup_dead;
 102
 103     AvahiAddress dns_servers[AVAHI_WIDE_AREA_SERVERS_MAX];
 104     unsigned n_dns_servers;
 105     unsigned current_dns_server;
 106 };
 107
 108 static AvahiWideAreaLookup* find_lookup(AvahiWideAreaLookupEngine *e, uint16_t id) {
 109     AvahiWideAreaLookup *l;
 110     int i = (int) id;
 111
 112     assert(e);
 113
 114     if (!(l = avahi_hashmap_lookup(e->lookups_by_id, &i)))
 115         return NULL;
 116
 117     assert(l->id == id);
 118
 119     if (l->dead)
 120         return NULL;
 121
 122     return l;
 123 }
 124
 125 static int send_to_dns_server(AvahiWideAreaLookup *l, AvahiDnsPacket *p) {
 126     AvahiAddress *a;
 127
 128     assert(l);
 129     assert(p);
 130
 131     if (l->engine->n_dns_servers <= 0)
 132         return -1;
 133
 134     assert(l->engine->current_dns_server < l->engine->n_dns_servers);
 135
 136     a = &l->engine->dns_servers[l->engine->current_dns_server];
 137     l->dns_server_used = *a;
 138
 139     if (a->proto == AVAHI_PROTO_INET) {
 140
 141         if (l->engine->fd_ipv4 < 0)
 142             return -1;
 143
 144         return avahi_send_dns_packet_ipv4(l->engine->fd_ipv4, AVAHI_IF_UNSPEC, p, NULL, &a->data.ipv4, AVAHI_DNS_PORT);
 145
 146     } else {
 147         assert(a->proto == AVAHI_PROTO_INET6);
 148
 149         if (l->engine->fd_ipv6 < 0)
 150             return -1;
 151
 152         return avahi_send_dns_packet_ipv6(l->engine->fd_ipv6, AVAHI_IF_UNSPEC, p, NULL, &a->data.ipv6, AVAHI_DNS_PORT);
 153     }
 154 }
 155
 156 static void next_dns_server(AvahiWideAreaLookupEngine *e) {
 157     assert(e);
 158
 159     e->current_dns_server++;
 160
 161     if (e->current_dns_server >= e->n_dns_servers)
 162         e->current_dns_server = 0;
 163 }
 164
 165 static void sender_timeout_callback(AvahiTimeEvent *e, void *userdata) {
 166     AvahiWideAreaLookup *l = userdata;
 167     struct timeval tv;
 168
 169     assert(l);
 170
 171     /* Try another DNS server after three retries */
 172     if (l->n_send >= 3 && avahi_address_cmp(&l->engine->dns_servers[l->engine->current_dns_server], &l->dns_server_used) == 0) {
 173         next_dns_server(l->engine);
 174
 175         if (avahi_address_cmp(&l->engine->dns_servers[l->engine->current_dns_server], &l->dns_server_used) == 0)
 176             /* There is no other DNS server, fail */
 177             l->n_send = 1000;
 178     }
 179
 180     if (l->n_send >= 6) {
 181         avahi_log_warn(__FILE__": Query timed out.");
 182         avahi_server_set_errno(l->engine->server, AVAHI_ERR_TIMEOUT);
 183         l->callback(l->engine, AVAHI_BROWSER_FAILURE, AVAHI_LOOKUP_RESULT_WIDE_AREA, NULL, l->userdata);
 184         avahi_wide_area_lookup_free(l);
 185         return;
 186     }
 187
 188     assert(l->packet);
 189     send_to_dns_server(l, l->packet);
 190     l->n_send++;
 191
 192     avahi_time_event_update(e, avahi_elapse_time(&tv, 1000, 0));
 193 }
 194
 195 AvahiWideAreaLookup *avahi_wide_area_lookup_new(
 196     AvahiWideAreaLookupEngine *e,
 197     AvahiKey *key,
 198     AvahiWideAreaLookupCallback callback,
 199     void *userdata) {
 200
 201     struct timeval tv;
 202     AvahiWideAreaLookup *l, *t;
 203     uint8_t *p;
 204
 205     assert(e);
 206     assert(key);
 207     assert(callback);
 208     assert(userdata);
 209
 210     l = avahi_new(AvahiWideAreaLookup, 1);
 211     l->engine = e;
 212     l->dead = 0;
 213     l->key = avahi_key_ref(key);
 214     l->cname_key = avahi_key_new_cname(l->key);
 215     l->callback = callback;
 216     l->userdata = userdata;
 217
 218     /* If more than 65K wide area quries are issued simultaneously,
 219      * this will break. This should be limited by some higher level */
 220
 221     for (;; e->next_id++)
 222         if (!find_lookup(e, e->next_id))
 223             break; /* This ID is not yet used. */
 224
 225     l->id = e->next_id++;
 226
 227     /* We keep the packet around in case we need to repeat our query */
 228     l->packet = avahi_dns_packet_new(0);
 229
 230     avahi_dns_packet_set_field(l->packet, AVAHI_DNS_FIELD_ID, (uint16_t) l->id);
 231     avahi_dns_packet_set_field(l->packet, AVAHI_DNS_FIELD_FLAGS, AVAHI_DNS_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, 0, 0));
 232
 233     p = avahi_dns_packet_append_key(l->packet, key, 0);
 234     assert(p);
 235
 236     avahi_dns_packet_set_field(l->packet, AVAHI_DNS_FIELD_QDCOUNT, 1);
 237
 238     if (send_to_dns_server(l, l->packet) < 0) {
 239         avahi_log_error(__FILE__": Failed to send packet.");
 240         avahi_dns_packet_free(l->packet);
 241         avahi_key_unref(l->key);
 242         if (l->cname_key)
 243             avahi_key_unref(l->cname_key);
 244         avahi_free(l);
 245         return NULL;
 246     }
 247
 248     l->n_send = 1;
 249
 250     l->time_event = avahi_time_event_new(e->server->time_event_queue, avahi_elapse_time(&tv, 500, 0), sender_timeout_callback, l);
 251
 252     avahi_hashmap_insert(e->lookups_by_id, &l->id, l);
 253
 254     t = avahi_hashmap_lookup(e->lookups_by_key, l->key);
 255     AVAHI_LLIST_PREPEND(AvahiWideAreaLookup, by_key, t, l);
 256     avahi_hashmap_replace(e->lookups_by_key, avahi_key_ref(l->key), t);
 257
 258     AVAHI_LLIST_PREPEND(AvahiWideAreaLookup, lookups, e->lookups, l);
 259
 260     return l;
 261 }
 262
 263 static void lookup_stop(AvahiWideAreaLookup *l) {
 264     assert(l);
 265
 266     l->callback = NULL;
 267
 268     if (l->time_event) {
 269         avahi_time_event_free(l->time_event);
 270         l->time_event = NULL;
 271     }
 272 }
 273
 274 static void lookup_destroy(AvahiWideAreaLookup *l) {
 275     AvahiWideAreaLookup *t;
 276     assert(l);
 277
 278     lookup_stop(l);
 279
 280     t = avahi_hashmap_lookup(l->engine->lookups_by_key, l->key);
 281     AVAHI_LLIST_REMOVE(AvahiWideAreaLookup, by_key, t, l);
 282     if (t)
 283         avahi_hashmap_replace(l->engine->lookups_by_key, avahi_key_ref(l->key), t);
 284     else
 285         avahi_hashmap_remove(l->engine->lookups_by_key, l->key);
 286
 287     AVAHI_LLIST_REMOVE(AvahiWideAreaLookup, lookups, l->engine->lookups, l);
 288
 289     avahi_hashmap_remove(l->engine->lookups_by_id, &l->id);
 290     avahi_dns_packet_free(l->packet);
 291
 292     if (l->key)
 293         avahi_key_unref(l->key);
 294
 295     if (l->cname_key)
 296         avahi_key_unref(l->cname_key);
 297
 298     avahi_free(l);
 299 }
 300
 301 void avahi_wide_area_lookup_free(AvahiWideAreaLookup *l) {
 302     assert(l);
 303
 304     if (l->dead)
 305         return;
 306
 307     l->dead = 1;
 308     l->engine->cleanup_dead = 1;
 309     lookup_stop(l);
 310 }
 311
 312 void avahi_wide_area_cleanup(AvahiWideAreaLookupEngine *e) {
 313     AvahiWideAreaLookup *l, *n;
 314     assert(e);
 315
 316     while (e->cleanup_dead) {
 317         e->cleanup_dead = 0;
 318
 319         for (l = e->lookups; l; l = n) {
 320             n = l->lookups_next;
 321
 322             if (l->dead)
 323                 lookup_destroy(l);
 324         }
 325     }
 326 }
 327
 328 static void cache_entry_free(AvahiWideAreaCacheEntry *c) {
 329     AvahiWideAreaCacheEntry *t;
 330     assert(c);
 331
 332     if (c->time_event)
 333         avahi_time_event_free(c->time_event);
 334
 335     AVAHI_LLIST_REMOVE(AvahiWideAreaCacheEntry, cache, c->engine->cache, c);
 336
 337     t = avahi_hashmap_lookup(c->engine->cache_by_key, c->record->key);
 338     AVAHI_LLIST_REMOVE(AvahiWideAreaCacheEntry, by_key, t, c);
 339     if (t)
 340         avahi_hashmap_replace(c->engine->cache_by_key, avahi_key_ref(c->record->key), t);
 341     else
 342         avahi_hashmap_remove(c->engine->cache_by_key, c->record->key);
 343
 344     c->engine->cache_n_entries --;
 345
 346     avahi_record_unref(c->record);
 347     avahi_free(c);
 348 }
 349
 350 static void expiry_event(AvahiTimeEvent *te, void *userdata) {
 351     AvahiWideAreaCacheEntry *e = userdata;
 352
 353     assert(te);
 354     assert(e);
 355
 356     cache_entry_free(e);
 357 }
 358
 359 static AvahiWideAreaCacheEntry* find_record_in_cache(AvahiWideAreaLookupEngine *e, AvahiRecord *r) {
 360     AvahiWideAreaCacheEntry *c;
 361
 362     assert(e);
 363     assert(r);
 364
 365     for (c = avahi_hashmap_lookup(e->cache_by_key, r->key); c; c = c->by_key_next)
 366         if (avahi_record_equal_no_ttl(r, c->record))
 367             return c;
 368
 369     return NULL;
 370 }
 371
 372 static void run_callbacks(AvahiWideAreaLookupEngine *e, AvahiRecord *r) {
 373     AvahiWideAreaLookup *l;
 374
 375     assert(e);
 376     assert(r);
 377
 378     for (l = avahi_hashmap_lookup(e->lookups_by_key, r->key); l; l = l->by_key_next) {
 379         if (l->dead || !l->callback)
 380             continue;
 381
 382         l->callback(e, AVAHI_BROWSER_NEW, AVAHI_LOOKUP_RESULT_WIDE_AREA, r, l->userdata);
 383     }
 384
 385     if (r->key->clazz == AVAHI_DNS_CLASS_IN && r->key->type == AVAHI_DNS_TYPE_CNAME) {
 386         /* It's a CNAME record, so we have to scan the all lookups to see if one matches */
 387
 388         for (l = e->lookups; l; l = l->lookups_next) {
 389             AvahiKey *key;
 390
 391             if (l->dead || !l->callback)
 392                 continue;
 393
 394             if ((key = avahi_key_new_cname(l->key))) {
 395                 if (avahi_key_equal(r->key, key))
 396                     l->callback(e, AVAHI_BROWSER_NEW, AVAHI_LOOKUP_RESULT_WIDE_AREA, r, l->userdata);
 397
 398                 avahi_key_unref(key);
 399             }
 400         }
 401     }
 402 }
 403
 404 static void add_to_cache(AvahiWideAreaLookupEngine *e, AvahiRecord *r) {
 405     AvahiWideAreaCacheEntry *c;
 406     int is_new;
 407
 408     assert(e);
 409     assert(r);
 410
 411     if ((c = find_record_in_cache(e, r))) {
 412         is_new = 0;
 413
 414         /* Update the existing entry */
 415         avahi_record_unref(c->record);
 416     } else {
 417         AvahiWideAreaCacheEntry *t;
 418
 419         is_new = 1;
 420
 421         /* Enforce cache size */
 422         if (e->cache_n_entries >= CACHE_ENTRIES_MAX)
 423             /* Eventually we should improve the caching algorithm here */
 424             goto finish;
 425
 426         c = avahi_new(AvahiWideAreaCacheEntry, 1);
 427         c->engine = e;
 428         c->time_event = NULL;
 429
 430         AVAHI_LLIST_PREPEND(AvahiWideAreaCacheEntry, cache, e->cache, c);
 431
 432         /* Add the new entry to the cache entry hash table */
 433         t = avahi_hashmap_lookup(e->cache_by_key, r->key);
 434         AVAHI_LLIST_PREPEND(AvahiWideAreaCacheEntry, by_key, t, c);
 435         avahi_hashmap_replace(e->cache_by_key, avahi_key_ref(r->key), t);
 436
 437         e->cache_n_entries ++;
 438     }
 439
 440     c->record = avahi_record_ref(r);
 441
 442     gettimeofday(&c->timestamp, NULL);
 443     c->expiry = c->timestamp;
 444     avahi_timeval_add(&c->expiry, r->ttl * 1000000);
 445
 446     if (c->time_event)
 447         avahi_time_event_update(c->time_event, &c->expiry);
 448     else
 449         c->time_event = avahi_time_event_new(e->server->time_event_queue, &c->expiry, expiry_event, c);
 450
 451 finish:
 452
 453     if (is_new)
 454         run_callbacks(e, r);
 455 }
 456
 457 static int map_dns_error(uint16_t error) {
 458     static const int table[16] = {
 459         AVAHI_OK,
 460         AVAHI_ERR_DNS_FORMERR,
 461         AVAHI_ERR_DNS_SERVFAIL,
 462         AVAHI_ERR_DNS_NXDOMAIN,
 463         AVAHI_ERR_DNS_NOTIMP,
 464         AVAHI_ERR_DNS_REFUSED,
 465         AVAHI_ERR_DNS_YXDOMAIN,
 466         AVAHI_ERR_DNS_YXRRSET,
 467         AVAHI_ERR_DNS_NXRRSET,
 468         AVAHI_ERR_DNS_NOTAUTH,
 469         AVAHI_ERR_DNS_NOTZONE,
 470         AVAHI_ERR_INVALID_DNS_ERROR,
 471         AVAHI_ERR_INVALID_DNS_ERROR,
 472         AVAHI_ERR_INVALID_DNS_ERROR,
 473         AVAHI_ERR_INVALID_DNS_ERROR,
 474         AVAHI_ERR_INVALID_DNS_ERROR
 475     };
 476
 477     assert(error <= 15);
 478
 479     return table[error];
 480 }
 481
 482 static void handle_packet(AvahiWideAreaLookupEngine *e, AvahiDnsPacket *p) {
 483     AvahiWideAreaLookup *l = NULL;
 484     int i, r;
 485
 486     AvahiBrowserEvent final_event = AVAHI_BROWSER_ALL_FOR_NOW;
 487
 488     assert(e);
 489     assert(p);
 490
 491     /* Some superficial validity tests */
 492     if (avahi_dns_packet_check_valid(p) < 0 || avahi_dns_packet_is_query(p)) {
 493         avahi_log_warn(__FILE__": Ignoring invalid response for wide area datagram.");
 494         goto finish;
 495     }
 496
 497     /* Look for the lookup that issued this query */
 498     if (!(l = find_lookup(e, avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ID))) || l->dead)
 499         goto finish;
 500
 501     /* Check whether this a packet indicating a failure */
 502     if ((r = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & 15) != 0 ||
 503         avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT) == 0) {
 504
 505         avahi_server_set_errno(e->server, r == 0 ? AVAHI_ERR_NOT_FOUND : map_dns_error(r));
 506         /* Tell the user about the failure */
 507         final_event = AVAHI_BROWSER_FAILURE;
 508
 509         /* We go on here, since some of the records contained in the
 510            reply might be interesting in some way */
 511     }
 512
 513     /* Skip over the question */
 514     for (i = (int) avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_QDCOUNT); i > 0; i--) {
 515         AvahiKey *k;
 516
 517         if (!(k = avahi_dns_packet_consume_key(p, NULL))) {
 518             avahi_log_warn(__FILE__": Wide area response packet too short.");
 519             avahi_server_set_errno(e->server, AVAHI_ERR_INVALID_PACKET);
 520             final_event = AVAHI_BROWSER_FAILURE;
 521             goto finish;
 522         }
 523
 524         avahi_key_unref(k);
 525     }
 526
 527     /* Process responses */
 528     for (i = (int) avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT) +
 529              (int) avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_NSCOUNT) +
 530              (int) avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ARCOUNT); i > 0; i--) {
 531
 532         AvahiRecord *rr;
 533
 534         if (!(rr = avahi_dns_packet_consume_record(p, NULL))) {
 535             avahi_log_warn(__FILE__": Wide area response packet too short (2).");
 536             avahi_server_set_errno(e->server, AVAHI_ERR_INVALID_PACKET);
 537             final_event = AVAHI_BROWSER_FAILURE;
 538             goto finish;
 539         }
 540
 541         add_to_cache(e, rr);
 542         avahi_record_unref(rr);
 543     }
 544
 545 finish:
 546
 547     if (l && !l->dead) {
 548         if (l->callback)
 549             l->callback(e, final_event, AVAHI_LOOKUP_RESULT_WIDE_AREA, NULL, l->userdata);
 550
 551         lookup_stop(l);
 552     }
 553 }
 554
 555 static void socket_event(AVAHI_GCC_UNUSED AvahiWatch *w, int fd, AVAHI_GCC_UNUSED AvahiWatchEvent events, void *userdata) {
 556     AvahiWideAreaLookupEngine *e = userdata;
 557     AvahiDnsPacket *p = NULL;
 558
 559     if (fd == e->fd_ipv4)
 560         p = avahi_recv_dns_packet_ipv4(e->fd_ipv4, NULL, NULL, NULL, NULL, NULL);
 561     else {
 562         assert(fd == e->fd_ipv6);
 563         p = avahi_recv_dns_packet_ipv6(e->fd_ipv6, NULL, NULL, NULL, NULL, NULL);
 564     }
 565
 566     if (p) {
 567         handle_packet(e, p);
 568         avahi_dns_packet_free(p);
 569     }
 570 }
 571
 572 AvahiWideAreaLookupEngine *avahi_wide_area_engine_new(AvahiServer *s) {
 573     AvahiWideAreaLookupEngine *e;
 574
 575     assert(s);
 576
 577     e = avahi_new(AvahiWideAreaLookupEngine, 1);
 578     e->server = s;
 579     e->cleanup_dead = 0;
 580
 581     /* Create sockets */
 582     e->fd_ipv4 = avahi_open_unicast_socket_ipv4();
 583     e->fd_ipv6 = avahi_open_unicast_socket_ipv6();
 584
 585     if (e->fd_ipv4 < 0 && e->fd_ipv6 < 0) {
 586         avahi_log_error(__FILE__": Failed to create wide area sockets: %s", strerror(errno));
 587
 588         if (e->fd_ipv6 >= 0)
 589             close(e->fd_ipv6);
 590
 591         if (e->fd_ipv4 >= 0)
 592             close(e->fd_ipv4);
 593
 594         avahi_free(e);
 595         return NULL;
 596     }
 597
 598     /* Create watches */
 599     if (e->fd_ipv4 >= 0)
 600         e->watch_ipv4 = s->poll_api->watch_new(e->server->poll_api, e->fd_ipv4, AVAHI_WATCH_IN, socket_event, e);
 601     if (e->fd_ipv6 >= 0)
 602         e->watch_ipv6 = s->poll_api->watch_new(e->server->poll_api, e->fd_ipv6, AVAHI_WATCH_IN, socket_event, e);
 603
 604     e->n_dns_servers = e->current_dns_server = 0;
 605     e->next_id = (uint16_t) rand();
 606
 607     /* Initialize cache */
 608     AVAHI_LLIST_HEAD_INIT(AvahiWideAreaCacheEntry, e->cache);
 609     e->cache_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, (AvahiFreeFunc) avahi_key_unref, NULL);
 610     e->cache_n_entries = 0;
 611
 612     /* Initialize lookup list */
 613     e->lookups_by_id = avahi_hashmap_new((AvahiHashFunc) avahi_int_hash, (AvahiEqualFunc) avahi_int_equal, NULL, NULL);
 614     e->lookups_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, (AvahiFreeFunc) avahi_key_unref, NULL);
 615     AVAHI_LLIST_HEAD_INIT(AvahiWideAreaLookup, e->lookups);
 616
 617     return e;
 618 }
 619
 620 void avahi_wide_area_engine_free(AvahiWideAreaLookupEngine *e) {
 621     assert(e);
 622
 623     avahi_wide_area_clear_cache(e);
 624
 625     while (e->lookups)
 626         lookup_destroy(e->lookups);
 627
 628     avahi_hashmap_free(e->cache_by_key);
 629     avahi_hashmap_free(e->lookups_by_id);
 630     avahi_hashmap_free(e->lookups_by_key);
 631
 632     if (e->watch_ipv4)
 633         e->server->poll_api->watch_free(e->watch_ipv4);
 634
 635     if (e->watch_ipv6)
 636         e->server->poll_api->watch_free(e->watch_ipv6);
 637
 638     if (e->fd_ipv6 >= 0)
 639         close(e->fd_ipv6);
 640
 641     if (e->fd_ipv4 >= 0)
 642         close(e->fd_ipv4);
 643
 644     avahi_free(e);
 645 }
 646
 647 void avahi_wide_area_clear_cache(AvahiWideAreaLookupEngine *e) {
 648     assert(e);
 649
 650     while (e->cache)
 651         cache_entry_free(e->cache);
 652
 653     assert(e->cache_n_entries == 0);
 654 }
 655
 656 void avahi_wide_area_set_servers(AvahiWideAreaLookupEngine *e, const AvahiAddress *a, unsigned n) {
 657     assert(e);
 658
 659     if (a) {
 660         for (e->n_dns_servers = 0; n > 0 && e->n_dns_servers < AVAHI_WIDE_AREA_SERVERS_MAX; a++, n--)
 661             if ((a->proto == AVAHI_PROTO_INET && e->fd_ipv4 >= 0) || (a->proto == AVAHI_PROTO_INET6 && e->fd_ipv6 >= 0))
 662                 e->dns_servers[e->n_dns_servers++] = *a;
 663     } else {
 664         assert(n == 0);
 665         e->n_dns_servers = 0;
 666     }
 667
 668     e->current_dns_server = 0;
 669
 670     avahi_wide_area_clear_cache(e);
 671 }
 672
 673 void avahi_wide_area_cache_dump(AvahiWideAreaLookupEngine *e, AvahiDumpCallback callback, void* userdata) {
 674     AvahiWideAreaCacheEntry *c;
 675
 676     assert(e);
 677     assert(callback);
 678
 679     callback(";; WIDE AREA CACHE ;;; ", userdata);
 680
 681     for (c = e->cache; c; c = c->cache_next) {
 682         char *t = avahi_record_to_string(c->record);
 683         callback(t, userdata);
 684         avahi_free(t);
 685     }
 686 }
 687
 688 unsigned avahi_wide_area_scan_cache(AvahiWideAreaLookupEngine *e, AvahiKey *key, AvahiWideAreaLookupCallback callback, void *userdata) {
 689     AvahiWideAreaCacheEntry *c;
 690     AvahiKey *cname_key;
 691     unsigned n = 0;
 692
 693     assert(e);
 694     assert(key);
 695     assert(callback);
 696
 697     for (c = avahi_hashmap_lookup(e->cache_by_key, key); c; c = c->by_key_next) {
 698         callback(e, AVAHI_BROWSER_NEW, AVAHI_LOOKUP_RESULT_WIDE_AREA|AVAHI_LOOKUP_RESULT_CACHED, c->record, userdata);
 699         n++;
 700     }
 701
 702     if ((cname_key = avahi_key_new_cname(key))) {
 703
 704         for (c = avahi_hashmap_lookup(e->cache_by_key, cname_key); c; c = c->by_key_next) {
 705             callback(e, AVAHI_BROWSER_NEW, AVAHI_LOOKUP_RESULT_WIDE_AREA|AVAHI_LOOKUP_RESULT_CACHED, c->record, userdata);
 706             n++;
 707         }
 708
 709         avahi_key_unref(cname_key);
 710     }
 711
 712     return n;
 713 }
 714
 715 int avahi_wide_area_has_servers(AvahiWideAreaLookupEngine *e) {
 716     assert(e);
 717
 718     return e->n_dns_servers > 0;
 719 }
 720
 721
 722