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 #include <errno.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <sys/types.h>
29 #include <sys/socket.h>
30 #include <netinet/in.h>
31 
32 #include <avahi-common/error.h>
33 #include "avahi-common/avahi-malloc.h"
34 #include <avahi-common/domain.h>
35 
36 #include "iface.h"
37 #include "dns.h"
38 #include "socket.h"
39 #include "announce.h"
40 #include "util.h"
41 #include "log.h"
42 #include "multicast-lookup.h"
43 #include "querier.h"
44 
avahi_interface_address_update_rrs(AvahiInterfaceAddress * a,int remove_rrs)45 void avahi_interface_address_update_rrs(AvahiInterfaceAddress *a, int remove_rrs) {
46     AvahiInterfaceMonitor *m;
47 
48     assert(a);
49     m = a->monitor;
50 
51     if (m->list_complete &&
52         avahi_interface_address_is_relevant(a) &&
53         avahi_interface_is_relevant(a->interface) &&
54         !remove_rrs &&
55         m->server->config.publish_addresses &&
56         (m->server->state == AVAHI_SERVER_RUNNING ||
57         m->server->state == AVAHI_SERVER_REGISTERING)) {
58 
59         /* Fill the entry group */
60         if (!a->entry_group)
61             a->entry_group = avahi_s_entry_group_new(m->server, avahi_host_rr_entry_group_callback, NULL);
62 
63         if (!a->entry_group) /* OOM */
64             return;
65 
66         if (avahi_s_entry_group_is_empty(a->entry_group)) {
67             char t[AVAHI_ADDRESS_STR_MAX];
68             AvahiProtocol p;
69 
70             p = (a->interface->protocol == AVAHI_PROTO_INET && m->server->config.publish_a_on_ipv6) ||
71                 (a->interface->protocol == AVAHI_PROTO_INET6 && m->server->config.publish_aaaa_on_ipv4) ? AVAHI_PROTO_UNSPEC : a->interface->protocol;
72 
73             avahi_address_snprint(t, sizeof(t), &a->address);
74             avahi_log_info("Registering new address record for %s on %s.%s.", t, a->interface->hardware->name, p == AVAHI_PROTO_UNSPEC ? "*" : avahi_proto_to_string(p));
75 
76             if (avahi_server_add_address(m->server, a->entry_group, a->interface->hardware->index, p, 0, NULL, &a->address) < 0) {
77                 avahi_log_warn(__FILE__": avahi_server_add_address() failed: %s", avahi_strerror(m->server->error));
78                 avahi_s_entry_group_free(a->entry_group);
79                 a->entry_group = NULL;
80                 return;
81             }
82 
83             avahi_s_entry_group_commit(a->entry_group);
84         }
85     } else {
86 
87         /* Clear the entry group */
88 
89         if (a->entry_group && !avahi_s_entry_group_is_empty(a->entry_group)) {
90             char t[AVAHI_ADDRESS_STR_MAX];
91             avahi_address_snprint(t, sizeof(t), &a->address);
92 
93             avahi_log_info("Withdrawing address record for %s on %s.", t, a->interface->hardware->name);
94 
95             if (avahi_s_entry_group_get_state(a->entry_group) == AVAHI_ENTRY_GROUP_REGISTERING &&
96                 m->server->state == AVAHI_SERVER_REGISTERING)
97                 avahi_server_decrease_host_rr_pending(m->server);
98 
99             avahi_s_entry_group_reset(a->entry_group);
100         }
101     }
102 }
103 
avahi_interface_update_rrs(AvahiInterface * i,int remove_rrs)104 void avahi_interface_update_rrs(AvahiInterface *i, int remove_rrs) {
105     AvahiInterfaceAddress *a;
106 
107     assert(i);
108 
109     for (a = i->addresses; a; a = a->address_next)
110         avahi_interface_address_update_rrs(a, remove_rrs);
111 }
112 
avahi_hw_interface_update_rrs(AvahiHwInterface * hw,int remove_rrs)113 void avahi_hw_interface_update_rrs(AvahiHwInterface *hw, int remove_rrs) {
114     AvahiInterface *i;
115     AvahiInterfaceMonitor *m;
116 
117     assert(hw);
118     m = hw->monitor;
119 
120     for (i = hw->interfaces; i; i = i->by_hardware_next)
121         avahi_interface_update_rrs(i, remove_rrs);
122 
123     if (m->list_complete &&
124         !remove_rrs &&
125         m->server->config.publish_workstation &&
126         (m->server->state == AVAHI_SERVER_RUNNING)) {
127 
128         if (!hw->entry_group)
129             hw->entry_group = avahi_s_entry_group_new(m->server, avahi_host_rr_entry_group_callback, NULL);
130 
131         if (!hw->entry_group)
132             return; /* OOM */
133 
134         if (avahi_s_entry_group_is_empty(hw->entry_group)) {
135             char name[AVAHI_LABEL_MAX], unescaped[AVAHI_LABEL_MAX], mac[256];
136             const char *p = m->server->host_name;
137 
138             avahi_unescape_label(&p, unescaped, sizeof(unescaped));
139             avahi_format_mac_address(mac, sizeof(mac), hw->mac_address, hw->mac_address_size);
140             snprintf(name, sizeof(name), "%s [%s]", unescaped, mac);
141 
142             if (avahi_server_add_service(m->server, hw->entry_group, hw->index, AVAHI_PROTO_UNSPEC, 0, name, "_workstation._tcp", NULL, NULL, 9, NULL) < 0) {
143                 avahi_log_warn(__FILE__": avahi_server_add_service() failed: %s", avahi_strerror(m->server->error));
144                 avahi_s_entry_group_free(hw->entry_group);
145                 hw->entry_group = NULL;
146             } else
147                 avahi_s_entry_group_commit(hw->entry_group);
148         }
149 
150     } else {
151 
152         if (hw->entry_group && !avahi_s_entry_group_is_empty(hw->entry_group)) {
153 
154             avahi_log_info("Withdrawing workstation service for %s.", hw->name);
155 
156             if (avahi_s_entry_group_get_state(hw->entry_group) == AVAHI_ENTRY_GROUP_REGISTERING &&
157                 m->server->state == AVAHI_SERVER_REGISTERING)
158                 avahi_server_decrease_host_rr_pending(m->server);
159 
160             avahi_s_entry_group_reset(hw->entry_group);
161         }
162     }
163 }
164 
avahi_interface_monitor_update_rrs(AvahiInterfaceMonitor * m,int remove_rrs)165 void avahi_interface_monitor_update_rrs(AvahiInterfaceMonitor *m, int remove_rrs) {
166     AvahiHwInterface *hw;
167 
168     assert(m);
169 
170     for (hw = m->hw_interfaces; hw; hw = hw->hardware_next)
171         avahi_hw_interface_update_rrs(hw, remove_rrs);
172 }
173 
interface_mdns_mcast_join(AvahiInterface * i,int join)174 static int interface_mdns_mcast_join(AvahiInterface *i, int join) {
175     char at[AVAHI_ADDRESS_STR_MAX];
176     int r;
177     assert(i);
178 
179     if (!!join  == !!i->mcast_joined)
180         return 0;
181 
182     if ((i->protocol == AVAHI_PROTO_INET6 && i->monitor->server->fd_ipv6 < 0) ||
183         (i->protocol == AVAHI_PROTO_INET && i->monitor->server->fd_ipv4 < 0))
184         return -1;
185 
186     if (join) {
187         AvahiInterfaceAddress *a;
188 
189         /* Look if there's an address with global scope */
190         for (a = i->addresses; a; a = a->address_next)
191             if (a->global_scope)
192                 break;
193 
194         /* No address with a global scope has been found, so let's use
195          * any. */
196         if (!a)
197             a = i->addresses;
198 
199         /* Hmm, there is no address available. */
200         if (!a)
201             return -1;
202 
203         i->local_mcast_address = a->address;
204     }
205 
206     avahi_log_info("%s mDNS multicast group on interface %s.%s with address %s.",
207                    join ? "Joining" : "Leaving",
208                    i->hardware->name,
209                    avahi_proto_to_string(i->protocol),
210                    avahi_address_snprint(at, sizeof(at), &i->local_mcast_address));
211 
212     if (i->protocol == AVAHI_PROTO_INET6)
213         r = avahi_mdns_mcast_join_ipv6(i->monitor->server->fd_ipv6, &i->local_mcast_address.data.ipv6, i->hardware->index, join);
214     else {
215         assert(i->protocol == AVAHI_PROTO_INET);
216 
217         r = avahi_mdns_mcast_join_ipv4(i->monitor->server->fd_ipv4, &i->local_mcast_address.data.ipv4, i->hardware->index, join);
218     }
219 
220     if (r < 0)
221         i->mcast_joined = 0;
222     else
223         i->mcast_joined = join;
224 
225     return 0;
226 }
227 
interface_mdns_mcast_rejoin(AvahiInterface * i)228 static int interface_mdns_mcast_rejoin(AvahiInterface *i) {
229     AvahiInterfaceAddress *a, *usable = NULL, *found = NULL;
230     assert(i);
231 
232     if (!i->mcast_joined)
233         return 0;
234 
235     /* Check whether old address we joined with is still available. If
236      * not, rejoin using an other address. */
237 
238     for (a = i->addresses; a; a = a->address_next) {
239         if (a->global_scope && !usable)
240             usable = a;
241 
242         if (avahi_address_cmp(&a->address, &i->local_mcast_address) == 0) {
243 
244             if (a->global_scope)
245                 /* No action necessary: the address still exists and
246                  * has global scope. */
247                 return 0;
248 
249             found = a;
250         }
251     }
252 
253     if (found && !usable)
254         /* No action necessary: the address still exists and no better one has been found */
255         return 0;
256 
257     interface_mdns_mcast_join(i, 0);
258     return interface_mdns_mcast_join(i, 1);
259 }
260 
avahi_interface_address_free(AvahiInterfaceAddress * a)261 void avahi_interface_address_free(AvahiInterfaceAddress *a) {
262     assert(a);
263     assert(a->interface);
264 
265     avahi_interface_address_update_rrs(a, 1);
266     AVAHI_LLIST_REMOVE(AvahiInterfaceAddress, address, a->interface->addresses, a);
267 
268     if (a->entry_group)
269         avahi_s_entry_group_free(a->entry_group);
270 
271     interface_mdns_mcast_rejoin(a->interface);
272 
273     avahi_free(a);
274 }
275 
avahi_interface_free(AvahiInterface * i,int send_goodbye)276 void avahi_interface_free(AvahiInterface *i, int send_goodbye) {
277     assert(i);
278 
279     /* Handle goodbyes and remove announcers */
280     avahi_goodbye_interface(i->monitor->server, i, send_goodbye, 1);
281     avahi_response_scheduler_force(i->response_scheduler);
282     assert(!i->announcers);
283 
284     if (i->mcast_joined)
285         interface_mdns_mcast_join(i, 0);
286 
287     /* Remove queriers */
288     avahi_querier_free_all(i);
289     avahi_hashmap_free(i->queriers_by_key);
290 
291     /* Remove local RRs */
292     avahi_interface_update_rrs(i, 1);
293 
294     while (i->addresses)
295         avahi_interface_address_free(i->addresses);
296 
297     avahi_response_scheduler_free(i->response_scheduler);
298     avahi_query_scheduler_free(i->query_scheduler);
299     avahi_probe_scheduler_free(i->probe_scheduler);
300     avahi_cache_free(i->cache);
301 
302     AVAHI_LLIST_REMOVE(AvahiInterface, interface, i->monitor->interfaces, i);
303     AVAHI_LLIST_REMOVE(AvahiInterface, by_hardware, i->hardware->interfaces, i);
304 
305     avahi_free(i);
306 }
307 
avahi_hw_interface_free(AvahiHwInterface * hw,int send_goodbye)308 void avahi_hw_interface_free(AvahiHwInterface *hw, int send_goodbye) {
309     assert(hw);
310 
311     avahi_hw_interface_update_rrs(hw, 1);
312 
313     while (hw->interfaces)
314         avahi_interface_free(hw->interfaces, send_goodbye);
315 
316     if (hw->entry_group)
317         avahi_s_entry_group_free(hw->entry_group);
318 
319     AVAHI_LLIST_REMOVE(AvahiHwInterface, hardware, hw->monitor->hw_interfaces, hw);
320     avahi_hashmap_remove(hw->monitor->hashmap, &hw->index);
321 
322     avahi_free(hw->name);
323     avahi_free(hw);
324 }
325 
avahi_interface_new(AvahiInterfaceMonitor * m,AvahiHwInterface * hw,AvahiProtocol protocol)326 AvahiInterface* avahi_interface_new(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, AvahiProtocol protocol) {
327     AvahiInterface *i;
328 
329     assert(m);
330     assert(hw);
331     assert(AVAHI_PROTO_VALID(protocol));
332 
333     if (!(i = avahi_new(AvahiInterface, 1)))
334         goto fail; /* OOM */
335 
336     i->monitor = m;
337     i->hardware = hw;
338     i->protocol = protocol;
339     i->announcing = 0;
340     i->mcast_joined = 0;
341 
342     AVAHI_LLIST_HEAD_INIT(AvahiInterfaceAddress, i->addresses);
343     AVAHI_LLIST_HEAD_INIT(AvahiAnnouncer, i->announcers);
344 
345     AVAHI_LLIST_HEAD_INIT(AvahiQuerier, i->queriers);
346     i->queriers_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, NULL, NULL);
347 
348     i->cache = avahi_cache_new(m->server, i);
349     i->response_scheduler = avahi_response_scheduler_new(i);
350     i->query_scheduler = avahi_query_scheduler_new(i);
351     i->probe_scheduler = avahi_probe_scheduler_new(i);
352 
353     if (!i->cache || !i->response_scheduler || !i->query_scheduler || !i->probe_scheduler)
354         goto fail; /* OOM */
355 
356     AVAHI_LLIST_PREPEND(AvahiInterface, by_hardware, hw->interfaces, i);
357     AVAHI_LLIST_PREPEND(AvahiInterface, interface, m->interfaces, i);
358 
359     return i;
360 
361 fail:
362 
363     if (i) {
364         if (i->cache)
365             avahi_cache_free(i->cache);
366         if (i->response_scheduler)
367             avahi_response_scheduler_free(i->response_scheduler);
368         if (i->query_scheduler)
369             avahi_query_scheduler_free(i->query_scheduler);
370         if (i->probe_scheduler)
371             avahi_probe_scheduler_free(i->probe_scheduler);
372     }
373 
374     return NULL;
375 }
376 
avahi_hw_interface_new(AvahiInterfaceMonitor * m,AvahiIfIndex idx)377 AvahiHwInterface *avahi_hw_interface_new(AvahiInterfaceMonitor *m, AvahiIfIndex idx) {
378     AvahiHwInterface *hw;
379 
380     assert(m);
381     assert(AVAHI_IF_VALID(idx));
382 
383     if  (!(hw = avahi_new(AvahiHwInterface, 1)))
384         return NULL;
385 
386     hw->monitor = m;
387     hw->name = NULL;
388     hw->flags_ok = 0;
389     hw->mtu = 1500;
390     hw->index = idx;
391     hw->mac_address_size = 0;
392     hw->entry_group = NULL;
393     hw->ratelimit_begin.tv_sec = 0;
394     hw->ratelimit_begin.tv_usec = 0;
395     hw->ratelimit_counter = 0;
396 
397     AVAHI_LLIST_HEAD_INIT(AvahiInterface, hw->interfaces);
398     AVAHI_LLIST_PREPEND(AvahiHwInterface, hardware, m->hw_interfaces, hw);
399 
400     avahi_hashmap_insert(m->hashmap, &hw->index, hw);
401 
402     if (m->server->fd_ipv4 >= 0 || m->server->config.publish_a_on_ipv6)
403         avahi_interface_new(m, hw, AVAHI_PROTO_INET);
404     if (m->server->fd_ipv6 >= 0 || m->server->config.publish_aaaa_on_ipv4)
405         avahi_interface_new(m, hw, AVAHI_PROTO_INET6);
406 
407     return hw;
408 }
409 
avahi_interface_address_new(AvahiInterfaceMonitor * m,AvahiInterface * i,const AvahiAddress * addr,unsigned prefix_len)410 AvahiInterfaceAddress *avahi_interface_address_new(AvahiInterfaceMonitor *m, AvahiInterface *i, const AvahiAddress *addr, unsigned prefix_len) {
411     AvahiInterfaceAddress *a;
412 
413     assert(m);
414     assert(i);
415 
416     if (!(a = avahi_new(AvahiInterfaceAddress, 1)))
417         return NULL;
418 
419     a->interface = i;
420     a->monitor = m;
421     a->address = *addr;
422     a->prefix_len = prefix_len;
423     a->global_scope = 0;
424     a->deprecated = 0;
425     a->entry_group = NULL;
426 
427     AVAHI_LLIST_PREPEND(AvahiInterfaceAddress, address, i->addresses, a);
428 
429     return a;
430 }
431 
avahi_interface_check_relevant(AvahiInterface * i)432 void avahi_interface_check_relevant(AvahiInterface *i) {
433     int b;
434     AvahiInterfaceMonitor *m;
435 
436     assert(i);
437     m = i->monitor;
438 
439     b = avahi_interface_is_relevant(i);
440 
441     if (m->list_complete && b && !i->announcing) {
442         interface_mdns_mcast_join(i, 1);
443 
444         if (i->mcast_joined) {
445             avahi_log_info("New relevant interface %s.%s for mDNS.", i->hardware->name, avahi_proto_to_string(i->protocol));
446 
447             i->announcing = 1;
448             avahi_announce_interface(m->server, i);
449             avahi_multicast_lookup_engine_new_interface(m->server->multicast_lookup_engine, i);
450         }
451 
452     } else if (!b && i->announcing) {
453         avahi_log_info("Interface %s.%s no longer relevant for mDNS.", i->hardware->name, avahi_proto_to_string(i->protocol));
454 
455         interface_mdns_mcast_join(i, 0);
456 
457         avahi_goodbye_interface(m->server, i, 0, 1);
458         avahi_querier_free_all(i);
459 
460         avahi_response_scheduler_clear(i->response_scheduler);
461         avahi_query_scheduler_clear(i->query_scheduler);
462         avahi_probe_scheduler_clear(i->probe_scheduler);
463         avahi_cache_flush(i->cache);
464 
465         i->announcing = 0;
466 
467     } else
468         interface_mdns_mcast_rejoin(i);
469 }
470 
avahi_hw_interface_check_relevant(AvahiHwInterface * hw)471 void avahi_hw_interface_check_relevant(AvahiHwInterface *hw) {
472     AvahiInterface *i;
473 
474     assert(hw);
475 
476     for (i = hw->interfaces; i; i = i->by_hardware_next)
477         avahi_interface_check_relevant(i);
478 }
479 
avahi_interface_monitor_check_relevant(AvahiInterfaceMonitor * m)480 void avahi_interface_monitor_check_relevant(AvahiInterfaceMonitor *m) {
481     AvahiInterface *i;
482 
483     assert(m);
484 
485     for (i = m->interfaces; i; i = i->interface_next)
486         avahi_interface_check_relevant(i);
487 }
488 
avahi_interface_monitor_new(AvahiServer * s)489 AvahiInterfaceMonitor *avahi_interface_monitor_new(AvahiServer *s) {
490     AvahiInterfaceMonitor *m = NULL;
491 
492     if (!(m = avahi_new0(AvahiInterfaceMonitor, 1)))
493         return NULL; /* OOM */
494 
495     m->server = s;
496     m->list_complete = 0;
497     m->hashmap = avahi_hashmap_new(avahi_int_hash, avahi_int_equal, NULL, NULL);
498 
499     AVAHI_LLIST_HEAD_INIT(AvahiInterface, m->interfaces);
500     AVAHI_LLIST_HEAD_INIT(AvahiHwInterface, m->hw_interfaces);
501 
502     if (avahi_interface_monitor_init_osdep(m) < 0)
503         goto fail;
504 
505     return m;
506 
507 fail:
508     avahi_interface_monitor_free(m);
509     return NULL;
510 }
511 
avahi_interface_monitor_free(AvahiInterfaceMonitor * m)512 void avahi_interface_monitor_free(AvahiInterfaceMonitor *m) {
513     assert(m);
514 
515     while (m->hw_interfaces)
516         avahi_hw_interface_free(m->hw_interfaces, 1);
517 
518     assert(!m->interfaces);
519 
520     avahi_interface_monitor_free_osdep(m);
521 
522     if (m->hashmap)
523         avahi_hashmap_free(m->hashmap);
524 
525     avahi_free(m);
526 }
527 
528 
avahi_interface_monitor_get_interface(AvahiInterfaceMonitor * m,AvahiIfIndex idx,AvahiProtocol protocol)529 AvahiInterface* avahi_interface_monitor_get_interface(AvahiInterfaceMonitor *m, AvahiIfIndex idx, AvahiProtocol protocol) {
530     AvahiHwInterface *hw;
531     AvahiInterface *i;
532 
533     assert(m);
534     assert(idx >= 0);
535     assert(protocol != AVAHI_PROTO_UNSPEC);
536 
537     if (!(hw = avahi_interface_monitor_get_hw_interface(m, idx)))
538         return NULL;
539 
540     for (i = hw->interfaces; i; i = i->by_hardware_next)
541         if (i->protocol == protocol)
542             return i;
543 
544     return NULL;
545 }
546 
avahi_interface_monitor_get_hw_interface(AvahiInterfaceMonitor * m,AvahiIfIndex idx)547 AvahiHwInterface* avahi_interface_monitor_get_hw_interface(AvahiInterfaceMonitor *m, AvahiIfIndex idx) {
548     assert(m);
549     assert(idx >= 0);
550 
551     return avahi_hashmap_lookup(m->hashmap, &idx);
552 }
553 
avahi_interface_monitor_get_address(AvahiInterfaceMonitor * m,AvahiInterface * i,const AvahiAddress * raddr)554 AvahiInterfaceAddress* avahi_interface_monitor_get_address(AvahiInterfaceMonitor *m, AvahiInterface *i, const AvahiAddress *raddr) {
555     AvahiInterfaceAddress *ia;
556 
557     assert(m);
558     assert(i);
559     assert(raddr);
560 
561     for (ia = i->addresses; ia; ia = ia->address_next)
562         if (avahi_address_cmp(&ia->address, raddr) == 0)
563             return ia;
564 
565     return NULL;
566 }
567 
avahi_interface_send_packet_unicast(AvahiInterface * i,AvahiDnsPacket * p,const AvahiAddress * a,uint16_t port)568 void avahi_interface_send_packet_unicast(AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, uint16_t port) {
569     assert(i);
570     assert(p);
571 
572     if (!i->announcing)
573         return;
574 
575     assert(!a || a->proto == i->protocol);
576 
577     if (i->monitor->server->config.ratelimit_interval > 0) {
578         struct timeval now, end;
579 
580         gettimeofday(&now, NULL);
581 
582         end = i->hardware->ratelimit_begin;
583         avahi_timeval_add(&end, i->monitor->server->config.ratelimit_interval);
584 
585         if (i->hardware->ratelimit_begin.tv_sec <= 0 ||
586             avahi_timeval_compare(&end, &now) < 0) {
587 
588             i->hardware->ratelimit_begin = now;
589             i->hardware->ratelimit_counter = 0;
590         }
591 
592         if (i->hardware->ratelimit_counter > i->monitor->server->config.ratelimit_burst)
593             return;
594 
595         i->hardware->ratelimit_counter++;
596     }
597 
598     if (i->protocol == AVAHI_PROTO_INET && i->monitor->server->fd_ipv4 >= 0)
599         avahi_send_dns_packet_ipv4(i->monitor->server->fd_ipv4, i->hardware->index, p, i->mcast_joined ? &i->local_mcast_address.data.ipv4 : NULL, a ? &a->data.ipv4 : NULL, port);
600     else if (i->protocol == AVAHI_PROTO_INET6 && i->monitor->server->fd_ipv6 >= 0)
601         avahi_send_dns_packet_ipv6(i->monitor->server->fd_ipv6, i->hardware->index, p, i->mcast_joined ? &i->local_mcast_address.data.ipv6 : NULL, a ? &a->data.ipv6 : NULL, port);
602 }
603 
avahi_interface_send_packet(AvahiInterface * i,AvahiDnsPacket * p)604 void avahi_interface_send_packet(AvahiInterface *i, AvahiDnsPacket *p) {
605     assert(i);
606     assert(p);
607 
608     avahi_interface_send_packet_unicast(i, p, NULL, 0);
609 }
610 
avahi_interface_post_query(AvahiInterface * i,AvahiKey * key,int immediately,unsigned * ret_id)611 int avahi_interface_post_query(AvahiInterface *i, AvahiKey *key, int immediately, unsigned *ret_id) {
612     assert(i);
613     assert(key);
614 
615     if (!i->announcing)
616         return 0;
617 
618     return avahi_query_scheduler_post(i->query_scheduler, key, immediately, ret_id);
619 }
620 
avahi_interface_withraw_query(AvahiInterface * i,unsigned id)621 int avahi_interface_withraw_query(AvahiInterface *i, unsigned id) {
622 
623     return avahi_query_scheduler_withdraw_by_id(i->query_scheduler, id);
624 }
625 
avahi_interface_post_response(AvahiInterface * i,AvahiRecord * record,int flush_cache,const AvahiAddress * querier,int immediately)626 int avahi_interface_post_response(AvahiInterface *i, AvahiRecord *record, int flush_cache, const AvahiAddress *querier, int immediately) {
627     assert(i);
628     assert(record);
629 
630     if (!i->announcing)
631         return 0;
632 
633     return avahi_response_scheduler_post(i->response_scheduler, record, flush_cache, querier, immediately);
634 }
635 
avahi_interface_post_probe(AvahiInterface * i,AvahiRecord * record,int immediately)636 int avahi_interface_post_probe(AvahiInterface *i, AvahiRecord *record, int immediately) {
637     assert(i);
638     assert(record);
639 
640     if (!i->announcing)
641         return 0;
642 
643     return avahi_probe_scheduler_post(i->probe_scheduler, record, immediately);
644 }
645 
avahi_dump_caches(AvahiInterfaceMonitor * m,AvahiDumpCallback callback,void * userdata)646 int avahi_dump_caches(AvahiInterfaceMonitor *m, AvahiDumpCallback callback, void* userdata) {
647     AvahiInterface *i;
648     assert(m);
649 
650     for (i = m->interfaces; i; i = i->interface_next) {
651         if (avahi_interface_is_relevant(i)) {
652             char ln[256];
653             snprintf(ln, sizeof(ln), ";;; INTERFACE %s.%s ;;;", i->hardware->name, avahi_proto_to_string(i->protocol));
654             callback(ln, userdata);
655             if (avahi_cache_dump(i->cache, callback, userdata) < 0)
656                 return -1;
657         }
658     }
659 
660     return 0;
661 }
662 
avahi_interface_is_relevant_internal(AvahiInterface * i)663 static int avahi_interface_is_relevant_internal(AvahiInterface *i) {
664     AvahiInterfaceAddress *a;
665 
666     assert(i);
667 
668     if (!i->hardware->flags_ok)
669         return 0;
670 
671     for (a = i->addresses; a; a = a->address_next)
672         if (avahi_interface_address_is_relevant(a))
673             return 1;
674 
675     return 0;
676 }
677 
avahi_interface_is_relevant(AvahiInterface * i)678 int avahi_interface_is_relevant(AvahiInterface *i) {
679     AvahiStringList *l;
680     assert(i);
681 
682     for (l = i->monitor->server->config.deny_interfaces; l; l = l->next)
683         if (strcasecmp((char*) l->text, i->hardware->name) == 0)
684             return 0;
685 
686     if (i->monitor->server->config.allow_interfaces) {
687 
688         for (l = i->monitor->server->config.allow_interfaces; l; l = l->next)
689             if (strcasecmp((char*) l->text, i->hardware->name) == 0)
690                 goto good;
691 
692         return 0;
693     }
694 
695 good:
696     return avahi_interface_is_relevant_internal(i);
697 }
698 
avahi_interface_address_is_relevant(AvahiInterfaceAddress * a)699 int avahi_interface_address_is_relevant(AvahiInterfaceAddress *a) {
700     AvahiInterfaceAddress *b;
701     assert(a);
702 
703     /* Publish public and non-deprecated IP addresses */
704     if (a->global_scope && !a->deprecated)
705         return 1;
706 
707     /* Publish link-local and deprecated IP addresses only if they are
708      * the only ones on the link */
709     for (b = a->interface->addresses; b; b = b->address_next) {
710         if (b == a)
711             continue;
712 
713         if (b->global_scope && !b->deprecated)
714             return 0;
715     }
716 
717     return 1;
718 }
719 
avahi_interface_match(AvahiInterface * i,AvahiIfIndex idx,AvahiProtocol protocol)720 int avahi_interface_match(AvahiInterface *i, AvahiIfIndex idx, AvahiProtocol protocol) {
721     assert(i);
722 
723     if (idx != AVAHI_IF_UNSPEC && idx != i->hardware->index)
724         return 0;
725 
726     if (protocol != AVAHI_PROTO_UNSPEC && protocol != i->protocol)
727         return 0;
728 
729     return 1;
730 }
731 
avahi_interface_monitor_walk(AvahiInterfaceMonitor * m,AvahiIfIndex interface,AvahiProtocol protocol,AvahiInterfaceMonitorWalkCallback callback,void * userdata)732 void avahi_interface_monitor_walk(AvahiInterfaceMonitor *m, AvahiIfIndex interface, AvahiProtocol protocol, AvahiInterfaceMonitorWalkCallback callback, void* userdata) {
733     assert(m);
734     assert(callback);
735 
736     if (interface != AVAHI_IF_UNSPEC) {
737         if (protocol != AVAHI_PROTO_UNSPEC) {
738             AvahiInterface *i;
739 
740             if ((i = avahi_interface_monitor_get_interface(m, interface, protocol)))
741                 callback(m, i, userdata);
742 
743         } else {
744             AvahiHwInterface *hw;
745             AvahiInterface *i;
746 
747             if ((hw = avahi_interface_monitor_get_hw_interface(m, interface)))
748                 for (i = hw->interfaces; i; i = i->by_hardware_next)
749                     if (avahi_interface_match(i, interface, protocol))
750                         callback(m, i, userdata);
751         }
752 
753     } else {
754         AvahiInterface *i;
755 
756         for (i = m->interfaces; i; i = i->interface_next)
757             if (avahi_interface_match(i, interface, protocol))
758                 callback(m, i, userdata);
759     }
760 }
761 
762 
avahi_address_is_local(AvahiInterfaceMonitor * m,const AvahiAddress * a)763 int avahi_address_is_local(AvahiInterfaceMonitor *m, const AvahiAddress *a) {
764     AvahiInterface *i;
765     AvahiInterfaceAddress *ia;
766     assert(m);
767     assert(a);
768 
769     for (i = m->interfaces; i; i = i->interface_next)
770         for (ia = i->addresses; ia; ia = ia->address_next)
771             if (avahi_address_cmp(a, &ia->address) == 0)
772                 return 1;
773 
774     return 0;
775 }
776 
avahi_interface_address_on_link(AvahiInterface * i,const AvahiAddress * a)777 int avahi_interface_address_on_link(AvahiInterface *i, const AvahiAddress *a) {
778     AvahiInterfaceAddress *ia;
779 
780     assert(i);
781     assert(a);
782 
783     if (a->proto != i->protocol)
784         return 0;
785 
786     for (ia = i->addresses; ia; ia = ia->address_next) {
787 
788         if (a->proto == AVAHI_PROTO_INET) {
789             uint32_t m;
790 
791             m = ~(((uint32_t) -1) >> ia->prefix_len);
792 
793             if ((ntohl(a->data.ipv4.address) & m) == (ntohl(ia->address.data.ipv4.address) & m))
794                 return 1;
795         } else {
796             unsigned j;
797             unsigned char pl;
798             assert(a->proto == AVAHI_PROTO_INET6);
799 
800             pl = ia->prefix_len;
801 
802             for (j = 0; j < 16; j++) {
803                 uint8_t m;
804 
805                 if (pl == 0)
806                     return 1;
807 
808                 if (pl >= 8) {
809                     m = 0xFF;
810                     pl -= 8;
811                 } else {
812                     m = ~(0xFF >> pl);
813                     pl = 0;
814                 }
815 
816                 if ((a->data.ipv6.address[j] & m) != (ia->address.data.ipv6.address[j] & m))
817                     break;
818             }
819         }
820     }
821 
822     return 0;
823 }
824 
avahi_interface_has_address(AvahiInterfaceMonitor * m,AvahiIfIndex iface,const AvahiAddress * a)825 int avahi_interface_has_address(AvahiInterfaceMonitor *m, AvahiIfIndex iface, const AvahiAddress *a) {
826     AvahiInterface *i;
827     AvahiInterfaceAddress *j;
828 
829     assert(m);
830     assert(iface != AVAHI_IF_UNSPEC);
831     assert(a);
832 
833     if (!(i = avahi_interface_monitor_get_interface(m, iface, a->proto)))
834         return 0;
835 
836     for (j = i->addresses; j; j = j->address_next)
837         if (avahi_address_cmp(a, &j->address) == 0)
838             return 1;
839 
840     return 0;
841 }
842 
avahi_find_interface_for_address(AvahiInterfaceMonitor * m,const AvahiAddress * a)843 AvahiIfIndex avahi_find_interface_for_address(AvahiInterfaceMonitor *m, const AvahiAddress *a) {
844     AvahiInterface *i;
845     assert(m);
846 
847     /* Some stupid OS don't support passing the interface index when a
848      * packet is received. We have to work around that limitation by
849      * looking for an interface that has the incoming address
850      * attached. This is sometimes ambiguous, but we have to live with
851      * it. */
852 
853     for (i = m->interfaces; i; i = i->interface_next) {
854         AvahiInterfaceAddress *ai;
855 
856         if (i->protocol != a->proto)
857             continue;
858 
859         for (ai = i->addresses; ai; ai = ai->address_next)
860             if (avahi_address_cmp(a, &ai->address) == 0)
861                 return i->hardware->index;
862     }
863 
864     return AVAHI_IF_UNSPEC;
865 }
866