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