]> git.meshlink.io Git - catta/blob - avahi-core/browse-dns-server.c
Merge remote branch 'origin/master-tx'
[catta] / avahi-core / browse-dns-server.c
1 /***
2   This file is part of avahi.
3
4   avahi is free software; you can redistribute it and/or modify it
5   under the terms of the GNU Lesser General Public License as
6   published by the Free Software Foundation; either version 2.1 of the
7   License, or (at your option) any later version.
8
9   avahi is distributed in the hope that it will be useful, but WITHOUT
10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
12   Public License for more details.
13
14   You should have received a copy of the GNU Lesser General Public
15   License along with avahi; if not, write to the Free Software
16   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
17   USA.
18 ***/
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <string.h>
25
26 #include <avahi-common/domain.h>
27 #include <avahi-common/malloc.h>
28 #include <avahi-common/error.h>
29
30 #include "browse.h"
31 #include "log.h"
32 #include "rr.h"
33
34 typedef struct AvahiDNSServerInfo AvahiDNSServerInfo;
35
36 struct AvahiDNSServerInfo {
37     AvahiSDNSServerBrowser *browser;
38
39     AvahiIfIndex interface;
40     AvahiProtocol protocol;
41     AvahiRecord *srv_record;
42     AvahiSHostNameResolver *host_name_resolver;
43     AvahiAddress address;
44     AvahiLookupResultFlags flags;
45
46     AVAHI_LLIST_FIELDS(AvahiDNSServerInfo, info);
47 };
48
49 struct AvahiSDNSServerBrowser {
50     AvahiServer *server;
51
52     AvahiSRecordBrowser *record_browser;
53     AvahiSDNSServerBrowserCallback callback;
54     void* userdata;
55     AvahiProtocol aprotocol;
56     AvahiLookupFlags user_flags;
57
58     unsigned n_info;
59
60     AVAHI_LLIST_FIELDS(AvahiSDNSServerBrowser, browser);
61     AVAHI_LLIST_HEAD(AvahiDNSServerInfo, info);
62 };
63
64 static AvahiDNSServerInfo* get_server_info(AvahiSDNSServerBrowser *b, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *r) {
65     AvahiDNSServerInfo *i;
66
67     assert(b);
68     assert(r);
69
70     for (i = b->info; i; i = i->info_next)
71         if (i->interface == interface &&
72             i->protocol == protocol &&
73             avahi_record_equal_no_ttl(r, i->srv_record))
74             return i;
75
76     return NULL;
77 }
78
79 static void server_info_free(AvahiSDNSServerBrowser *b, AvahiDNSServerInfo *i) {
80     assert(b);
81     assert(i);
82
83     avahi_record_unref(i->srv_record);
84     if (i->host_name_resolver)
85         avahi_s_host_name_resolver_free(i->host_name_resolver);
86
87     AVAHI_LLIST_REMOVE(AvahiDNSServerInfo, info, b->info, i);
88
89     assert(b->n_info >= 1);
90     b->n_info--;
91
92     avahi_free(i);
93 }
94
95 static void host_name_resolver_callback(
96     AvahiSHostNameResolver *r,
97     AVAHI_GCC_UNUSED AvahiIfIndex interface,
98     AVAHI_GCC_UNUSED AvahiProtocol protocol,
99     AvahiResolverEvent event,
100     const char *host_name,
101     const AvahiAddress *a,
102     AvahiLookupResultFlags flags,
103     void* userdata) {
104
105     AvahiDNSServerInfo *i = userdata;
106
107     assert(r);
108     assert(host_name);
109     assert(i);
110
111     switch (event) {
112         case AVAHI_RESOLVER_FOUND: {
113             i->address = *a;
114
115             i->browser->callback(
116                 i->browser,
117                 i->interface,
118                 i->protocol,
119                 AVAHI_BROWSER_NEW,
120                 i->srv_record->data.srv.name,
121                 &i->address,
122                 i->srv_record->data.srv.port,
123                 i->flags | flags,
124                 i->browser->userdata);
125
126             break;
127         }
128
129         case AVAHI_RESOLVER_FAILURE:
130             /* Ignore */
131             break;
132     }
133
134     avahi_s_host_name_resolver_free(i->host_name_resolver);
135     i->host_name_resolver = NULL;
136 }
137
138 static void record_browser_callback(
139     AvahiSRecordBrowser*rr,
140     AvahiIfIndex interface,
141     AvahiProtocol protocol,
142     AvahiBrowserEvent event,
143     AvahiRecord *record,
144     AvahiLookupResultFlags flags,
145     void* userdata) {
146
147     AvahiSDNSServerBrowser *b = userdata;
148
149     assert(rr);
150     assert(b);
151
152     /* Filter flags */
153     flags &= AVAHI_LOOKUP_RESULT_CACHED | AVAHI_LOOKUP_RESULT_MULTICAST | AVAHI_LOOKUP_RESULT_WIDE_AREA;
154
155     switch (event) {
156         case AVAHI_BROWSER_NEW: {
157             AvahiDNSServerInfo *i;
158
159             assert(record);
160             assert(record->key->type == AVAHI_DNS_TYPE_SRV);
161
162             if (get_server_info(b, interface, protocol, record))
163                 return;
164
165             if (b->n_info >= 10)
166                 return;
167
168             if (!(i = avahi_new(AvahiDNSServerInfo, 1)))
169                 return; /* OOM */
170
171             i->browser = b;
172             i->interface = interface;
173             i->protocol = protocol;
174             i->srv_record = avahi_record_ref(record);
175             i->host_name_resolver = avahi_s_host_name_resolver_new(
176                 b->server,
177                 interface, protocol,
178                 record->data.srv.name,
179                 b->aprotocol,
180                 b->user_flags,
181                 host_name_resolver_callback, i);
182             i->flags = flags;
183
184             AVAHI_LLIST_PREPEND(AvahiDNSServerInfo, info, b->info, i);
185
186             b->n_info++;
187             break;
188         }
189
190         case AVAHI_BROWSER_REMOVE: {
191             AvahiDNSServerInfo *i;
192
193             assert(record);
194             assert(record->key->type == AVAHI_DNS_TYPE_SRV);
195
196             if (!(i = get_server_info(b, interface, protocol, record)))
197                 return;
198
199             if (!i->host_name_resolver)
200                 b->callback(
201                     b,
202                     interface,
203                     protocol,
204                     event,
205                     i->srv_record->data.srv.name,
206                     &i->address,
207                     i->srv_record->data.srv.port,
208                     i->flags | flags,
209                     b->userdata);
210
211             server_info_free(b, i);
212             break;
213         }
214
215         case AVAHI_BROWSER_FAILURE:
216         case AVAHI_BROWSER_ALL_FOR_NOW:
217         case AVAHI_BROWSER_CACHE_EXHAUSTED:
218
219             b->callback(
220                 b,
221                 interface,
222                 protocol,
223                 event,
224                 NULL,
225                 NULL,
226                 0,
227                 flags,
228                 b->userdata);
229
230             break;
231     }
232 }
233
234 AvahiSDNSServerBrowser *avahi_s_dns_server_browser_new(
235     AvahiServer *server,
236     AvahiIfIndex interface,
237     AvahiProtocol protocol,
238     const char *domain,
239     AvahiDNSServerType type,
240     AvahiProtocol aprotocol,
241     AvahiLookupFlags flags,
242     AvahiSDNSServerBrowserCallback callback,
243     void* userdata) {
244
245     static const char * const type_table[AVAHI_DNS_SERVER_MAX] = {
246         "_domain._udp",
247         "_dns-update._udp"
248     };
249
250     AvahiSDNSServerBrowser *b;
251     AvahiKey *k = NULL;
252     char n[AVAHI_DOMAIN_NAME_MAX];
253     int r;
254
255     assert(server);
256     assert(callback);
257
258     AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
259     AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_PROTO_VALID(protocol), AVAHI_ERR_INVALID_PROTOCOL);
260     AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_PROTO_VALID(aprotocol), AVAHI_ERR_INVALID_PROTOCOL);
261     AVAHI_CHECK_VALIDITY_RETURN_NULL(server, !domain || avahi_is_valid_domain_name(domain), AVAHI_ERR_INVALID_DOMAIN_NAME);
262     AVAHI_CHECK_VALIDITY_RETURN_NULL(server, AVAHI_FLAGS_VALID(flags, AVAHI_LOOKUP_USE_WIDE_AREA|AVAHI_LOOKUP_USE_MULTICAST), AVAHI_ERR_INVALID_FLAGS);
263     AVAHI_CHECK_VALIDITY_RETURN_NULL(server, type < AVAHI_DNS_SERVER_MAX, AVAHI_ERR_INVALID_FLAGS);
264
265     if (!domain)
266         domain = server->domain_name;
267
268     if ((r = avahi_service_name_join(n, sizeof(n), NULL, type_table[type], domain)) < 0) {
269         avahi_server_set_errno(server, r);
270         return NULL;
271     }
272
273     if (!(b = avahi_new(AvahiSDNSServerBrowser, 1))) {
274         avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY);
275         return NULL;
276     }
277
278     b->server = server;
279     b->callback = callback;
280     b->userdata = userdata;
281     b->aprotocol = aprotocol;
282     b->n_info = 0;
283     b->user_flags = flags;
284
285     AVAHI_LLIST_HEAD_INIT(AvahiDNSServerInfo, b->info);
286     AVAHI_LLIST_PREPEND(AvahiSDNSServerBrowser, browser, server->dns_server_browsers, b);
287
288     if (!(k = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV))) {
289         avahi_server_set_errno(server, AVAHI_ERR_NO_MEMORY);
290         goto fail;
291     }
292
293     if (!(b->record_browser = avahi_s_record_browser_new(server, interface, protocol, k, flags, record_browser_callback, b)))
294         goto fail;
295
296     avahi_key_unref(k);
297
298     return b;
299
300 fail:
301
302     if (k)
303         avahi_key_unref(k);
304
305     avahi_s_dns_server_browser_free(b);
306     return NULL;
307 }
308
309 void avahi_s_dns_server_browser_free(AvahiSDNSServerBrowser *b) {
310     assert(b);
311
312     while (b->info)
313         server_info_free(b, b->info);
314
315     AVAHI_LLIST_REMOVE(AvahiSDNSServerBrowser, browser, b->server->dns_server_browsers, b);
316
317     if (b->record_browser)
318         avahi_s_record_browser_free(b->record_browser);
319
320     avahi_free(b);
321 }
322