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