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