]> git.meshlink.io Git - catta/blob - wide-area.c
add81c7e920efb67e81f38fd61bc4881f9e2deb6
[catta] / 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 lookup_stop(AvahiWideAreaLookup *l) {
166     assert(l);
167     
168     l->callback = NULL;
169
170     if (l->time_event) {
171         avahi_time_event_free(l->time_event);
172         l->time_event = NULL;
173     }
174 }
175
176 static void sender_timeout_callback(AvahiTimeEvent *e, void *userdata) {
177     AvahiWideAreaLookup *l = userdata;
178     struct timeval tv;
179
180     assert(l);
181
182     /* Try another DNS server after three retries */
183     if (l->n_send >= 3 && avahi_address_cmp(&l->engine->dns_servers[l->engine->current_dns_server], &l->dns_server_used) == 0) {
184         next_dns_server(l->engine);
185
186         if (avahi_address_cmp(&l->engine->dns_servers[l->engine->current_dns_server], &l->dns_server_used) == 0)
187             /* There is no other DNS server, fail */
188             l->n_send = 1000;
189     }
190     
191     if (l->n_send >= 6) {
192         avahi_log_warn(__FILE__": Query timed out.");
193         avahi_server_set_errno(l->engine->server, AVAHI_ERR_TIMEOUT);
194         l->callback(l->engine, AVAHI_BROWSER_FAILURE, AVAHI_LOOKUP_RESULT_WIDE_AREA, NULL, l->userdata);
195         lookup_stop(l);
196         return;
197     }
198
199     assert(l->packet);
200     send_to_dns_server(l, l->packet);
201     l->n_send++;
202
203     avahi_time_event_update(e, avahi_elapse_time(&tv, 1000, 0));
204 }
205
206 AvahiWideAreaLookup *avahi_wide_area_lookup_new(
207     AvahiWideAreaLookupEngine *e,
208     AvahiKey *key,
209     AvahiWideAreaLookupCallback callback,
210     void *userdata) {
211     
212     struct timeval tv;
213     AvahiWideAreaLookup *l, *t;
214     uint8_t *p;
215
216     assert(e);
217     assert(key);
218     assert(callback);
219     assert(userdata);
220
221     l = avahi_new(AvahiWideAreaLookup, 1);
222     l->engine = e;
223     l->dead = 0;
224     l->key = avahi_key_ref(key);
225     l->cname_key = avahi_key_new_cname(l->key);
226     l->callback = callback;
227     l->userdata = userdata;
228
229     /* If more than 65K wide area quries are issued simultaneously,
230      * this will break. This should be limited by some higher level */
231
232     for (;; e->next_id++)
233         if (!find_lookup(e, e->next_id))
234             break; /* This ID is not yet used. */
235
236     l->id = e->next_id++;
237     
238     /* We keep the packet around in case we need to repeat our query */
239     l->packet = avahi_dns_packet_new(0);
240
241     avahi_dns_packet_set_field(l->packet, AVAHI_DNS_FIELD_ID, (uint16_t) l->id);
242     avahi_dns_packet_set_field(l->packet, AVAHI_DNS_FIELD_FLAGS, AVAHI_DNS_FLAGS(0, 0, 0, 0, 1, 0, 0, 0, 0, 0));
243
244     p = avahi_dns_packet_append_key(l->packet, key, 0);
245     assert(p);
246     
247     avahi_dns_packet_set_field(l->packet, AVAHI_DNS_FIELD_QDCOUNT, 1);
248
249     if (send_to_dns_server(l, l->packet) < 0) {
250         avahi_log_error(__FILE__": Failed to send packet.");
251         avahi_dns_packet_free(l->packet);
252         avahi_key_unref(l->key);
253         if (l->cname_key)
254             avahi_key_unref(l->cname_key);
255         avahi_free(l);
256         return NULL;
257     }
258
259     l->n_send = 1;
260     
261     l->time_event = avahi_time_event_new(e->server->time_event_queue, avahi_elapse_time(&tv, 500, 0), sender_timeout_callback, l);
262
263     avahi_hashmap_insert(e->lookups_by_id, &l->id, l);
264
265     t = avahi_hashmap_lookup(e->lookups_by_key, l->key);
266     AVAHI_LLIST_PREPEND(AvahiWideAreaLookup, by_key, t, l);
267     avahi_hashmap_replace(e->lookups_by_key, avahi_key_ref(l->key), t);
268
269     AVAHI_LLIST_PREPEND(AvahiWideAreaLookup, lookups, e->lookups, l);
270     
271     return l;
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 or invalid while reading question key. (Maybe a UTF-8 problem?)");
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 or invalid while reading response record. (Maybe a UTF-8 problem?)");
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 = s->config.use_ipv4 ? avahi_open_unicast_socket_ipv4() : -1;
583     e->fd_ipv6 = s->config.use_ipv6 ? avahi_open_unicast_socket_ipv6() : -1;
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
600     e->watch_ipv4 = e->watch_ipv6 = NULL;
601     
602     if (e->fd_ipv4 >= 0)
603         e->watch_ipv4 = s->poll_api->watch_new(e->server->poll_api, e->fd_ipv4, AVAHI_WATCH_IN, socket_event, e);
604     if (e->fd_ipv6 >= 0)
605         e->watch_ipv6 = s->poll_api->watch_new(e->server->poll_api, e->fd_ipv6, AVAHI_WATCH_IN, socket_event, e);
606
607     e->n_dns_servers = e->current_dns_server = 0;
608     e->next_id = (uint16_t) rand();
609
610     /* Initialize cache */
611     AVAHI_LLIST_HEAD_INIT(AvahiWideAreaCacheEntry, e->cache);
612     e->cache_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, (AvahiFreeFunc) avahi_key_unref, NULL);
613     e->cache_n_entries = 0;
614
615     /* Initialize lookup list */
616     e->lookups_by_id = avahi_hashmap_new((AvahiHashFunc) avahi_int_hash, (AvahiEqualFunc) avahi_int_equal, NULL, NULL);
617     e->lookups_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, (AvahiFreeFunc) avahi_key_unref, NULL);
618     AVAHI_LLIST_HEAD_INIT(AvahiWideAreaLookup, e->lookups);
619
620     return e;
621 }
622
623 void avahi_wide_area_engine_free(AvahiWideAreaLookupEngine *e) {
624     assert(e);
625     
626     avahi_wide_area_clear_cache(e);
627
628     while (e->lookups)
629         lookup_destroy(e->lookups);
630     
631     avahi_hashmap_free(e->cache_by_key);
632     avahi_hashmap_free(e->lookups_by_id);
633     avahi_hashmap_free(e->lookups_by_key);
634
635     if (e->watch_ipv4)
636         e->server->poll_api->watch_free(e->watch_ipv4);
637
638     if (e->watch_ipv6)
639         e->server->poll_api->watch_free(e->watch_ipv6);
640
641     if (e->fd_ipv6 >= 0)
642         close(e->fd_ipv6);
643     
644     if (e->fd_ipv4 >= 0)
645         close(e->fd_ipv4);
646
647     avahi_free(e);
648 }
649
650 void avahi_wide_area_clear_cache(AvahiWideAreaLookupEngine *e) {
651     assert(e);
652
653     while (e->cache)
654         cache_entry_free(e->cache);
655
656     assert(e->cache_n_entries == 0);
657 }
658
659 void avahi_wide_area_set_servers(AvahiWideAreaLookupEngine *e, const AvahiAddress *a, unsigned n) {
660     assert(e);
661
662     if (a) {
663         for (e->n_dns_servers = 0; n > 0 && e->n_dns_servers < AVAHI_WIDE_AREA_SERVERS_MAX; a++, n--) 
664             if ((a->proto == AVAHI_PROTO_INET && e->fd_ipv4 >= 0) || (a->proto == AVAHI_PROTO_INET6 && e->fd_ipv6 >= 0))
665                 e->dns_servers[e->n_dns_servers++] = *a;
666     } else {
667         assert(n == 0);
668         e->n_dns_servers = 0;
669     }
670     
671     e->current_dns_server = 0;
672
673     avahi_wide_area_clear_cache(e);
674 }
675
676 void avahi_wide_area_cache_dump(AvahiWideAreaLookupEngine *e, AvahiDumpCallback callback, void* userdata) {
677     AvahiWideAreaCacheEntry *c;
678     
679     assert(e);
680     assert(callback);
681
682     callback(";; WIDE AREA CACHE ;;; ", userdata);
683     
684     for (c = e->cache; c; c = c->cache_next) {
685         char *t = avahi_record_to_string(c->record);
686         callback(t, userdata);
687         avahi_free(t);
688     }
689 }
690
691 unsigned avahi_wide_area_scan_cache(AvahiWideAreaLookupEngine *e, AvahiKey *key, AvahiWideAreaLookupCallback callback, void *userdata) {
692     AvahiWideAreaCacheEntry *c;
693     AvahiKey *cname_key;
694     unsigned n = 0;
695     
696     assert(e);
697     assert(key);
698     assert(callback);
699
700     for (c = avahi_hashmap_lookup(e->cache_by_key, key); c; c = c->by_key_next) {
701         callback(e, AVAHI_BROWSER_NEW, AVAHI_LOOKUP_RESULT_WIDE_AREA|AVAHI_LOOKUP_RESULT_CACHED, c->record, userdata);
702         n++;
703     }
704
705     if ((cname_key = avahi_key_new_cname(key))) {
706
707         for (c = avahi_hashmap_lookup(e->cache_by_key, cname_key); c; c = c->by_key_next) {
708             callback(e, AVAHI_BROWSER_NEW, AVAHI_LOOKUP_RESULT_WIDE_AREA|AVAHI_LOOKUP_RESULT_CACHED, c->record, userdata);
709             n++;
710         }
711         
712         avahi_key_unref(cname_key);
713     }
714
715     return n;
716 }
717
718 int avahi_wide_area_has_servers(AvahiWideAreaLookupEngine *e) {
719     assert(e);
720
721     return e->n_dns_servers > 0;
722 }
723
724
725