]> git.meshlink.io Git - catta/blob - avahi-core/wide-area.c
handle wide areas responses with ANCOUNT = 0 like NXDOMAIN
[catta] / 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     AvahiBrowserEvent final_event = AVAHI_BROWSER_ALL_FOR_NOW;
455     
456     assert(e);
457     assert(p);
458
459     /* Some superficial validity tests */
460     if (avahi_dns_packet_check_valid(p) < 0 || avahi_dns_packet_is_query(p)) {
461         avahi_log_warn(__FILE__": Ignoring invalid response for wide area datagram.");
462         goto finish;
463     }
464
465     /* Look for the lookup that issued this query */
466     if (!(l = find_lookup(e, avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ID))) || l->dead)
467         goto finish;
468
469     /* Check whether this a packet indicating a failure */
470     if ((r = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & 15) != 0 ||
471         avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT) == 0) {
472
473         /* Tell the user about the failure */
474         final_event = r == 3 ? AVAHI_BROWSER_NOT_FOUND : AVAHI_BROWSER_FAILURE;
475
476         /* We go on here, since some of the records contained in the
477            reply might be interesting in some way */
478     }
479
480     /* Skip over the question */
481     for (i = (int) avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_QDCOUNT); i > 0; i--) {
482         AvahiKey *k;
483         
484         if (!(k = avahi_dns_packet_consume_key(p, NULL))) {
485             avahi_log_warn(__FILE__": Wide area response packet too short.");
486             final_event = AVAHI_BROWSER_FAILURE;
487             goto finish;
488         }
489
490         avahi_key_unref(k);
491     }
492
493     /* Process responses */
494     for (i = (int) avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT) +
495              (int) avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_NSCOUNT) +
496              (int) avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ARCOUNT); i > 0; i--) {
497
498         AvahiRecord *rr;
499
500         if (!(rr = avahi_dns_packet_consume_record(p, NULL))) {
501             avahi_log_warn(__FILE__": Wide area response packet too short (2).");
502             final_event = AVAHI_BROWSER_FAILURE;
503             goto finish;
504         }
505
506         add_to_cache(e, rr);
507         avahi_record_unref(rr);
508     }
509
510 finish:
511     
512     if (l && !l->dead) {
513         if (l->callback)
514             l->callback(e, final_event, AVAHI_LOOKUP_RESULT_WIDE_AREA, NULL, l->userdata);
515
516         lookup_stop(l);
517     }
518 }
519
520 static void socket_event(AvahiWatch *w, int fd, AvahiWatchEvent events, void *userdata) {
521     AvahiWideAreaLookupEngine *e = userdata;
522     AvahiAddress a;
523     AvahiDnsPacket *p = NULL;
524     
525     if (fd == e->fd_ipv4) {
526         struct sockaddr_in sa;
527             
528         if ((p = avahi_recv_dns_packet_ipv4(e->fd_ipv4, &sa, NULL, NULL, NULL)))
529             avahi_address_from_sockaddr((struct sockaddr*) &sa, &a);
530             
531     } else if (fd == e->fd_ipv6) {
532         struct sockaddr_in6 sa6;
533         
534         if ((p = avahi_recv_dns_packet_ipv6(e->fd_ipv6, &sa6, NULL, NULL, NULL)))
535             avahi_address_from_sockaddr((struct sockaddr*) &sa6, &a);
536
537     }
538
539     if (p) {
540         handle_packet(e, p, &a);
541         avahi_dns_packet_free(p);
542     }
543 }
544
545 AvahiWideAreaLookupEngine *avahi_wide_area_engine_new(AvahiServer *s) {
546     AvahiWideAreaLookupEngine *e;
547     
548     assert(s);
549
550     e = avahi_new(AvahiWideAreaLookupEngine, 1);
551     e->server = s;
552     e->cleanup_dead = 0;
553
554     /* Create sockets */
555     e->fd_ipv4 = avahi_open_unicast_socket_ipv4();
556     e->fd_ipv6 = avahi_open_unicast_socket_ipv6();
557
558     if (e->fd_ipv4 < 0 && e->fd_ipv6 < 0) {
559         avahi_log_error(__FILE__": Failed to create wide area sockets: %s", strerror(errno));
560
561         if (e->fd_ipv6 >= 0)
562             close(e->fd_ipv6);
563
564         if (e->fd_ipv4 >= 0)
565             close(e->fd_ipv4);
566         
567         avahi_free(e);
568         return NULL;
569     }
570
571     /* Create watches */
572     if (e->fd_ipv4 >= 0)
573         e->watch_ipv4 = s->poll_api->watch_new(e->server->poll_api, e->fd_ipv4, AVAHI_WATCH_IN, socket_event, e);
574     if (e->fd_ipv6 >= 0)
575         e->watch_ipv6 = s->poll_api->watch_new(e->server->poll_api, e->fd_ipv6, AVAHI_WATCH_IN, socket_event, e);
576
577     e->n_dns_servers = e->current_dns_server = 0;
578     e->next_id = (uint16_t) rand();
579
580     /* Initialize cache */
581     AVAHI_LLIST_HEAD_INIT(AvahiWideAreaCacheEntry, e->cache);
582     e->cache_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, (AvahiFreeFunc) avahi_key_unref, NULL);
583     e->cache_n_entries = 0;
584
585     /* Initialize lookup list */
586     e->lookups_by_id = avahi_hashmap_new((AvahiHashFunc) avahi_int_hash, (AvahiEqualFunc) avahi_int_equal, NULL, NULL);
587     e->lookups_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, (AvahiFreeFunc) avahi_key_unref, NULL);
588     AVAHI_LLIST_HEAD_INIT(AvahiWideAreaLookup, e->lookups);
589
590     return e;
591 }
592
593 void avahi_wide_area_engine_free(AvahiWideAreaLookupEngine *e) {
594     assert(e);
595     
596     avahi_wide_area_clear_cache(e);
597
598     while (e->lookups)
599         lookup_destroy(e->lookups);
600     
601     avahi_hashmap_free(e->cache_by_key);
602     avahi_hashmap_free(e->lookups_by_id);
603     avahi_hashmap_free(e->lookups_by_key);
604
605     if (e->watch_ipv4)
606         e->server->poll_api->watch_free(e->watch_ipv4);
607
608     if (e->watch_ipv6)
609         e->server->poll_api->watch_free(e->watch_ipv6);
610
611     if (e->fd_ipv6 >= 0)
612         close(e->fd_ipv6);
613     
614     if (e->fd_ipv4 >= 0)
615         close(e->fd_ipv4);
616
617     avahi_free(e);
618 }
619
620 void avahi_wide_area_clear_cache(AvahiWideAreaLookupEngine *e) {
621     assert(e);
622
623     while (e->cache)
624         cache_entry_free(e->cache);
625
626     assert(e->cache_n_entries == 0);
627 }
628
629
630 void avahi_wide_area_set_servers(AvahiWideAreaLookupEngine *e, const AvahiAddress *a, unsigned n) {
631     assert(e);
632
633     
634     if (a) {
635         for (e->n_dns_servers = 0; n > 0 && e->n_dns_servers < AVAHI_MAX_WIDE_AREA_SERVERS; a++, n--) 
636             if ((a->proto == AVAHI_PROTO_INET && e->fd_ipv4 >= 0) || (a->proto == AVAHI_PROTO_INET6 && e->fd_ipv6 >= 0))
637                 e->dns_servers[e->n_dns_servers++] = *a;
638     } else {
639         assert(n == 0);
640         e->n_dns_servers = 0;
641     }
642     
643     e->current_dns_server = 0;
644
645     avahi_wide_area_clear_cache(e);
646 }
647
648 void avahi_wide_area_cache_dump(AvahiWideAreaLookupEngine *e, AvahiDumpCallback callback, void* userdata) {
649     AvahiWideAreaCacheEntry *c;
650     
651     assert(e);
652     assert(callback);
653
654     callback(";; WIDE AREA CACHE ;;; ", userdata);
655     
656     for (c = e->cache; c; c = c->cache_next) {
657         char *t = avahi_record_to_string(c->record);
658         callback(t, userdata);
659         avahi_free(t);
660     }
661 }
662
663 unsigned avahi_wide_area_scan_cache(AvahiWideAreaLookupEngine *e, AvahiKey *key, AvahiWideAreaLookupCallback callback, void *userdata) {
664     AvahiWideAreaCacheEntry *c;
665     AvahiKey *cname_key;
666     unsigned n = 0;
667     
668     assert(e);
669     assert(key);
670     assert(callback);
671
672     for (c = avahi_hashmap_lookup(e->cache_by_key, key); c; c = c->by_key_next) {
673         callback(e, AVAHI_BROWSER_NEW, AVAHI_LOOKUP_RESULT_WIDE_AREA|AVAHI_LOOKUP_RESULT_CACHED, c->record, userdata);
674         n++;
675     }
676
677     if ((cname_key = avahi_key_new_cname(key))) {
678
679         for (c = avahi_hashmap_lookup(e->cache_by_key, cname_key); c; c = c->by_key_next) {
680             callback(e, AVAHI_BROWSER_NEW, AVAHI_LOOKUP_RESULT_WIDE_AREA|AVAHI_LOOKUP_RESULT_CACHED, c->record, userdata);
681             n++;
682         }
683         
684         avahi_key_unref(cname_key);
685     }
686
687     return n;
688 }
689
690 int avahi_wide_area_has_servers(AvahiWideAreaLookupEngine *e) {
691     assert(e);
692
693     return e->n_dns_servers > 0;
694 }
695
696
697