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
45void 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
104void 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
113void 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
165void 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
174static 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
228static 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
261void 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
276void 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
308void 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
326AvahiInterface* 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
361fail:
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
377AvahiHwInterface *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
410AvahiInterfaceAddress *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
432void 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
471void 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
480void 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
489AvahiInterfaceMonitor *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
507fail:
508    avahi_interface_monitor_free(m);
509    return NULL;
510}
511
512void 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
529AvahiInterface* 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
547AvahiHwInterface* 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
554AvahiInterfaceAddress* 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
568void 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
604void 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
611int 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
621int avahi_interface_withraw_query(AvahiInterface *i, unsigned id) {
622
623    return avahi_query_scheduler_withdraw_by_id(i->query_scheduler, id);
624}
625
626int 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
636int 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
646int 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
663static 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
678int 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
695good:
696    return avahi_interface_is_relevant_internal(i);
697}
698
699int 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
720int 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
732void 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
763int 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
777int 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
825int 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
843AvahiIfIndex 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