git.meshlink.io Git - catta/blob - avahi-core/iface.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 <string.h>
  27 #include <sys/socket.h>
  28 #include <asm/types.h>
  29 #include <linux/netlink.h>
  30 #include <linux/rtnetlink.h>
  31 #include <errno.h>
  32 #include <net/if.h>
  33 #include <stdio.h>
  34
  35 #include <avahi-common/malloc.h>
  36
  37 #include "iface.h"
  38 #include "netlink.h"
  39 #include "dns.h"
  40 #include "socket.h"
  41 #include "announce.h"
  42 #include "util.h"
  43 #include "log.h"
  44
  45 static void update_address_rr(AvahiInterfaceMonitor *m, AvahiInterfaceAddress *a, int remove_rrs) {
  46     assert(m);
  47     assert(a);
  48
  49     if (avahi_interface_address_relevant(a) &&
  50         !remove_rrs &&
  51         m->server->config.publish_addresses &&
  52         (m->server->state == AVAHI_SERVER_RUNNING ||
  53         m->server->state == AVAHI_SERVER_REGISTERING)) {
  54
  55         /* Fill the entry group */
  56         if (!a->entry_group)
  57             a->entry_group = avahi_entry_group_new(m->server, avahi_host_rr_entry_group_callback, NULL);
  58
  59         if (!a->entry_group) /* OOM */
  60             return;
  61
  62         if (avahi_entry_group_is_empty(a->entry_group)) {
  63
  64             if (avahi_server_add_address(m->server, a->entry_group, a->interface->hardware->index, a->interface->protocol, 0, NULL, &a->address) < 0) {
  65                 avahi_log_warn(__FILE__": avahi_server_add_address() failed: %s", avahi_strerror(m->server->error));
  66                 avahi_entry_group_free(a->entry_group);
  67                 a->entry_group = NULL;
  68                 return;
  69             }
  70
  71             avahi_entry_group_commit(a->entry_group);
  72         }
  73     } else {
  74
  75         /* Clear the entry group */
  76
  77         if (a->entry_group && !avahi_entry_group_is_empty(a->entry_group)) {
  78
  79             if (avahi_entry_group_get_state(a->entry_group) == AVAHI_ENTRY_GROUP_REGISTERING)
  80                 avahi_server_decrease_host_rr_pending(m->server);
  81
  82             avahi_entry_group_reset(a->entry_group);
  83         }
  84     }
  85 }
  86
  87 static void update_interface_rr(AvahiInterfaceMonitor *m, AvahiInterface *i, int remove_rrs) {
  88     AvahiInterfaceAddress *a;
  89
  90     assert(m);
  91     assert(i);
  92
  93     for (a = i->addresses; a; a = a->address_next)
  94         update_address_rr(m, a, remove_rrs);
  95 }
  96
  97 static void update_hw_interface_rr(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, int remove_rrs) {
  98     AvahiInterface *i;
  99
 100     assert(m);
 101     assert(hw);
 102
 103     for (i = hw->interfaces; i; i = i->by_hardware_next)
 104         update_interface_rr(m, i, remove_rrs);
 105
 106     if (!remove_rrs &&
 107         m->server->config.publish_workstation &&
 108         (m->server->state == AVAHI_SERVER_RUNNING ||
 109         m->server->state == AVAHI_SERVER_REGISTERING)) {
 110
 111         if (!hw->entry_group)
 112             hw->entry_group = avahi_entry_group_new(m->server, avahi_host_rr_entry_group_callback, NULL);
 113
 114         if (!hw->entry_group)
 115             return; /* OOM */
 116
 117         if (avahi_entry_group_is_empty(hw->entry_group)) {
 118             char *name;
 119             char *t;
 120
 121             if (!(t = avahi_format_mac_address(hw->mac_address, hw->mac_address_size)))
 122                 return; /* OOM */
 123
 124             name = avahi_strdup_printf("%s [%s]", m->server->host_name, t);
 125             avahi_free(t);
 126
 127             if (!name)
 128                 return; /* OOM */
 129
 130             if (avahi_server_add_service(m->server, hw->entry_group, hw->index, AVAHI_PROTO_UNSPEC, name, "_workstation._tcp", NULL, NULL, 9, NULL) < 0) {
 131                 avahi_log_warn(__FILE__": avahi_server_add_service() failed.");
 132                 avahi_entry_group_free(hw->entry_group);
 133                 hw->entry_group = NULL;
 134             } else
 135                 avahi_entry_group_commit(hw->entry_group);
 136
 137             avahi_free(name);
 138         }
 139
 140     } else {
 141
 142         if (hw->entry_group && !avahi_entry_group_is_empty(hw->entry_group)) {
 143
 144             if (avahi_entry_group_get_state(hw->entry_group) == AVAHI_ENTRY_GROUP_REGISTERING)
 145                 avahi_server_decrease_host_rr_pending(m->server);
 146
 147             avahi_entry_group_reset(hw->entry_group);
 148         }
 149     }
 150 }
 151
 152 static void free_address(AvahiInterfaceMonitor *m, AvahiInterfaceAddress *a) {
 153     assert(m);
 154     assert(a);
 155     assert(a->interface);
 156
 157     update_address_rr(m, a, 1);
 158     AVAHI_LLIST_REMOVE(AvahiInterfaceAddress, address, a->interface->addresses, a);
 159
 160     if (a->entry_group)
 161         avahi_entry_group_free(a->entry_group);
 162
 163     avahi_free(a);
 164 }
 165
 166 static void free_interface(AvahiInterfaceMonitor *m, AvahiInterface *i, int send_goodbye) {
 167     assert(m);
 168     assert(i);
 169
 170     avahi_goodbye_interface(m->server, i, send_goodbye);
 171     avahi_response_scheduler_force(i->response_scheduler);
 172
 173     assert(!i->announcements);
 174
 175     update_interface_rr(m, i, 1);
 176
 177     while (i->addresses)
 178         free_address(m, i->addresses);
 179
 180     avahi_response_scheduler_free(i->response_scheduler);
 181     avahi_query_scheduler_free(i->query_scheduler);
 182     avahi_probe_scheduler_free(i->probe_scheduler);
 183     avahi_cache_free(i->cache);
 184
 185     AVAHI_LLIST_REMOVE(AvahiInterface, interface, m->interfaces, i);
 186     AVAHI_LLIST_REMOVE(AvahiInterface, by_hardware, i->hardware->interfaces, i);
 187
 188     avahi_free(i);
 189 }
 190
 191 static void free_hw_interface(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, int send_goodbye) {
 192     assert(m);
 193     assert(hw);
 194
 195     update_hw_interface_rr(m, hw, 1);
 196
 197     while (hw->interfaces)
 198         free_interface(m, hw->interfaces, send_goodbye);
 199
 200     if (hw->entry_group)
 201         avahi_entry_group_free(hw->entry_group);
 202
 203     AVAHI_LLIST_REMOVE(AvahiHwInterface, hardware, m->hw_interfaces, hw);
 204     avahi_hashmap_remove(m->hashmap, &hw->index);
 205
 206     avahi_free(hw->name);
 207     avahi_free(hw);
 208 }
 209
 210 static AvahiInterfaceAddress* get_address(AvahiInterfaceMonitor *m, AvahiInterface *i, const AvahiAddress *raddr) {
 211     AvahiInterfaceAddress *ia;
 212
 213     assert(m);
 214     assert(i);
 215     assert(raddr);
 216
 217     for (ia = i->addresses; ia; ia = ia->address_next)
 218         if (avahi_address_cmp(&ia->address, raddr) == 0)
 219             return ia;
 220
 221     return NULL;
 222 }
 223
 224 static int netlink_list_items(AvahiNetlink *nl, uint16_t type, unsigned *ret_seq) {
 225     struct nlmsghdr *n;
 226     struct rtgenmsg *gen;
 227     uint8_t req[1024];
 228
 229     memset(&req, 0, sizeof(req));
 230     n = (struct nlmsghdr*) req;
 231     n->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
 232     n->nlmsg_type = type;
 233     n->nlmsg_flags = NLM_F_ROOT/*|NLM_F_MATCH*/|NLM_F_REQUEST;
 234     n->nlmsg_pid = 0;
 235
 236     gen = NLMSG_DATA(n);
 237     memset(gen, 0, sizeof(struct rtgenmsg));
 238     gen->rtgen_family = AF_UNSPEC;
 239
 240     return avahi_netlink_send(nl, n, ret_seq);
 241 }
 242
 243 static void new_interface(AvahiInterfaceMonitor *m, AvahiHwInterface *hw, AvahiProtocol protocol) {
 244     AvahiInterface *i;
 245
 246     assert(m);
 247     assert(hw);
 248     assert(protocol != AVAHI_PROTO_UNSPEC);
 249
 250     if (!(i = avahi_new(AvahiInterface, 1)))
 251         goto fail; /* OOM */
 252
 253     i->monitor = m;
 254     i->hardware = hw;
 255     i->protocol = protocol;
 256     i->announcing = 0;
 257
 258     AVAHI_LLIST_HEAD_INIT(AvahiInterfaceAddress, i->addresses);
 259     AVAHI_LLIST_HEAD_INIT(AvahiAnnouncement, i->announcements);
 260
 261     i->cache = avahi_cache_new(m->server, i);
 262     i->response_scheduler = avahi_response_scheduler_new(i);
 263     i->query_scheduler = avahi_query_scheduler_new(i);
 264     i->probe_scheduler = avahi_probe_scheduler_new(i);
 265
 266     if (!i->cache || !i->response_scheduler || !i->query_scheduler || !i->probe_scheduler)
 267         goto fail; /* OOM */
 268
 269     AVAHI_LLIST_PREPEND(AvahiInterface, by_hardware, hw->interfaces, i);
 270     AVAHI_LLIST_PREPEND(AvahiInterface, interface, m->interfaces, i);
 271
 272     return;
 273 fail:
 274
 275     if (i) {
 276         if (i->cache)
 277             avahi_cache_free(i->cache);
 278         if (i->response_scheduler)
 279             avahi_response_scheduler_free(i->response_scheduler);
 280         if (i->query_scheduler)
 281             avahi_query_scheduler_free(i->query_scheduler);
 282         if (i->probe_scheduler)
 283             avahi_probe_scheduler_free(i->probe_scheduler);
 284     }
 285
 286 }
 287
 288 static void check_interface_relevant(AvahiInterfaceMonitor *m, AvahiInterface *i) {
 289     int b;
 290
 291     assert(m);
 292     assert(i);
 293
 294     b = avahi_interface_relevant(i);
 295
 296     if (b && !i->announcing) {
 297         avahi_log_debug("New relevant interface %s.%i (#%i)", i->hardware->name, i->protocol, i->hardware->index);
 298
 299         if (i->protocol == AVAHI_PROTO_INET)
 300             avahi_mdns_mcast_join_ipv4(m->server->fd_ipv4, i->hardware->index);
 301         if (i->protocol == AVAHI_PROTO_INET6)
 302             avahi_mdns_mcast_join_ipv6(m->server->fd_ipv6, i->hardware->index);
 303
 304         i->announcing = 1;
 305         avahi_announce_interface(m->server, i);
 306         avahi_browser_new_interface(m->server, i);
 307     } else if (!b && i->announcing) {
 308         avahi_log_debug("Interface %s.%i no longer relevant", i->hardware->name, i->protocol);
 309
 310         if (i->protocol == AVAHI_PROTO_INET)
 311             avahi_mdns_mcast_leave_ipv4(m->server->fd_ipv4, i->hardware->index);
 312         if (i->protocol == AVAHI_PROTO_INET6)
 313             avahi_mdns_mcast_leave_ipv6(m->server->fd_ipv6, i->hardware->index);
 314
 315         avahi_goodbye_interface(m->server, i, 0);
 316         avahi_response_scheduler_clear(i->response_scheduler);
 317         avahi_query_scheduler_clear(i->query_scheduler);
 318         avahi_probe_scheduler_clear(i->probe_scheduler);
 319         avahi_cache_flush(i->cache);
 320
 321         i->announcing = 0;
 322     }
 323 }
 324
 325 static void check_hw_interface_relevant(AvahiInterfaceMonitor *m, AvahiHwInterface *hw) {
 326     AvahiInterface *i;
 327
 328     assert(m);
 329     assert(hw);
 330
 331     for (i = hw->interfaces; i; i = i->by_hardware_next)
 332         check_interface_relevant(m, i);
 333 }
 334
 335 static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, void* userdata) {
 336     AvahiInterfaceMonitor *m = userdata;
 337
 338     assert(m);
 339     assert(n);
 340     assert(m->netlink == nl);
 341
 342     if (n->nlmsg_type == RTM_NEWLINK) {
 343         struct ifinfomsg *ifinfomsg = NLMSG_DATA(n);
 344         AvahiHwInterface *hw;
 345         struct rtattr *a = NULL;
 346         size_t l;
 347
 348         if (ifinfomsg->ifi_family != AF_UNSPEC)
 349             return;
 350
 351         if (!(hw = avahi_hashmap_lookup(m->hashmap, &ifinfomsg->ifi_index))) {
 352
 353             if (!(hw = avahi_new(AvahiHwInterface, 1)))
 354                 return; /* OOM */
 355
 356             hw->monitor = m;
 357             hw->name = NULL;
 358             hw->flags = 0;
 359             hw->mtu = 1500;
 360             hw->index = (AvahiIfIndex) ifinfomsg->ifi_index;
 361             hw->mac_address_size = 0;
 362             hw->entry_group = NULL;
 363
 364             AVAHI_LLIST_HEAD_INIT(AvahiInterface, hw->interfaces);
 365             AVAHI_LLIST_PREPEND(AvahiHwInterface, hardware, m->hw_interfaces, hw);
 366
 367             avahi_hashmap_insert(m->hashmap, &hw->index, hw);
 368
 369             if (m->server->fd_ipv4 >= 0)
 370                 new_interface(m, hw, AVAHI_PROTO_INET);
 371             if (m->server->fd_ipv6 >= 0)
 372                 new_interface(m, hw, AVAHI_PROTO_INET6);
 373         }
 374
 375         hw->flags = ifinfomsg->ifi_flags;
 376
 377         l = NLMSG_PAYLOAD(n, sizeof(struct ifinfomsg));
 378         a = IFLA_RTA(ifinfomsg);
 379
 380         while (RTA_OK(a, l)) {
 381             switch(a->rta_type) {
 382                 case IFLA_IFNAME:
 383                     avahi_free(hw->name);
 384                     hw->name = avahi_strndup(RTA_DATA(a), RTA_PAYLOAD(a));
 385                     break;
 386
 387                 case IFLA_MTU:
 388                     assert(RTA_PAYLOAD(a) == sizeof(unsigned int));
 389                     hw->mtu = *((unsigned int*) RTA_DATA(a));
 390                     break;
 391
 392                 case IFLA_ADDRESS: {
 393                     hw->mac_address_size = RTA_PAYLOAD(a);
 394                     if (hw->mac_address_size > AVAHI_MAX_MAC_ADDRESS)
 395                         hw->mac_address_size = AVAHI_MAX_MAC_ADDRESS;
 396
 397                     memcpy(hw->mac_address, RTA_DATA(a), hw->mac_address_size);
 398                     break;
 399                 }
 400
 401                 default:
 402                     ;
 403             }
 404
 405             a = RTA_NEXT(a, l);
 406         }
 407
 408         update_hw_interface_rr(m, hw, 0);
 409         check_hw_interface_relevant(m, hw);
 410
 411     } else if (n->nlmsg_type == RTM_DELLINK) {
 412         struct ifinfomsg *ifinfomsg = NLMSG_DATA(n);
 413         AvahiHwInterface *hw;
 414
 415         if (ifinfomsg->ifi_family != AF_UNSPEC)
 416             return;
 417
 418         if (!(hw = avahi_interface_monitor_get_hw_interface(m, (AvahiIfIndex) ifinfomsg->ifi_index)))
 419             return;
 420
 421         update_hw_interface_rr(m, hw, 1);
 422         free_hw_interface(m, hw, 0);
 423
 424     } else if (n->nlmsg_type == RTM_NEWADDR || n->nlmsg_type == RTM_DELADDR) {
 425
 426         struct ifaddrmsg *ifaddrmsg = NLMSG_DATA(n);
 427         AvahiInterface *i;
 428         struct rtattr *a = NULL;
 429         size_t l;
 430         AvahiAddress raddr;
 431         int raddr_valid = 0;
 432
 433         if (ifaddrmsg->ifa_family != AVAHI_PROTO_INET && ifaddrmsg->ifa_family != AVAHI_PROTO_INET6)
 434             return;
 435
 436         if (!(i = (AvahiInterface*) avahi_interface_monitor_get_interface(m, (AvahiIfIndex) ifaddrmsg->ifa_index, (AvahiProtocol) ifaddrmsg->ifa_family)))
 437             return;
 438
 439         raddr.family = (AvahiProtocol) ifaddrmsg->ifa_family;
 440
 441         l = NLMSG_PAYLOAD(n, sizeof(struct ifaddrmsg));
 442         a = IFA_RTA(ifaddrmsg);
 443
 444         while (RTA_OK(a, l)) {
 445
 446             switch(a->rta_type) {
 447                 case IFA_ADDRESS:
 448                     if ((raddr.family == AVAHI_PROTO_INET6 && RTA_PAYLOAD(a) != 16) ||
 449                         (raddr.family == AVAHI_PROTO_INET && RTA_PAYLOAD(a) != 4))
 450                         return;
 451
 452                     memcpy(raddr.data.data, RTA_DATA(a), RTA_PAYLOAD(a));
 453                     raddr_valid = 1;
 454
 455                     break;
 456
 457                 default:
 458                     ;
 459             }
 460
 461             a = RTA_NEXT(a, l);
 462         }
 463
 464         if (!raddr_valid)
 465             return;
 466
 467         if (n->nlmsg_type == RTM_NEWADDR) {
 468             AvahiInterfaceAddress *addr;
 469
 470             if (!(addr = get_address(m, i, &raddr))) {
 471                 if (!(addr = avahi_new(AvahiInterfaceAddress, 1)))
 472                     return; /* OOM */
 473
 474                 addr->monitor = m;
 475                 addr->address = raddr;
 476                 addr->interface = i;
 477                 addr->entry_group = NULL;
 478
 479                 AVAHI_LLIST_PREPEND(AvahiInterfaceAddress, address, i->addresses, addr);
 480             }
 481
 482             addr->flags = ifaddrmsg->ifa_flags;
 483             addr->scope = ifaddrmsg->ifa_scope;
 484             addr->prefix_len = ifaddrmsg->ifa_prefixlen;
 485
 486             update_address_rr(m, addr, 0);
 487         } else {
 488             AvahiInterfaceAddress *addr;
 489
 490             if (!(addr = get_address(m, i, &raddr)))
 491                 return;
 492
 493             update_address_rr(m, addr, 1);
 494             free_address(m, addr);
 495         }
 496
 497         check_interface_relevant(m, i);
 498
 499     } else if (n->nlmsg_type == NLMSG_DONE) {
 500
 501         if (m->list == LIST_IFACE) {
 502             m->list = LIST_DONE;
 503
 504             if (netlink_list_items(m->netlink, RTM_GETADDR, &m->query_addr_seq) < 0)
 505                 avahi_log_warn("NETLINK: Failed to list addrs: %s", strerror(errno));
 506             else
 507                 m->list = LIST_ADDR;
 508         } else {
 509             m->list = LIST_DONE;
 510             avahi_log_debug("Enumeration complete");
 511         }
 512
 513     } else if (n->nlmsg_type == NLMSG_ERROR && (n->nlmsg_seq == m->query_link_seq || n->nlmsg_seq == m->query_addr_seq)) {
 514         struct nlmsgerr *e = NLMSG_DATA (n);
 515
 516         if (e->error)
 517             avahi_log_warn("NETLINK: Failed to browse: %s", strerror(-e->error));
 518     }
 519 }
 520
 521 AvahiInterfaceMonitor *avahi_interface_monitor_new(AvahiServer *s) {
 522     AvahiInterfaceMonitor *m = NULL;
 523
 524     if (!(m = avahi_new0(AvahiInterfaceMonitor, 1)))
 525         return NULL; /* OOM */
 526
 527     m->server = s;
 528     if (!(m->netlink = avahi_netlink_new(s->poll_api, RTMGRP_LINK|RTMGRP_IPV4_IFADDR|RTMGRP_IPV6_IFADDR, netlink_callback, m)))
 529         goto fail;
 530
 531     m->hashmap = avahi_hashmap_new(avahi_int_hash, avahi_int_equal, NULL, NULL);
 532
 533     AVAHI_LLIST_HEAD_INIT(AvahiInterface, m->interfaces);
 534     AVAHI_LLIST_HEAD_INIT(AvahiHwInterface, m->hw_interfaces);
 535
 536     if (netlink_list_items(m->netlink, RTM_GETLINK, &m->query_link_seq) < 0)
 537         goto fail;
 538
 539     m->list = LIST_IFACE;
 540
 541     return m;
 542
 543 fail:
 544     avahi_interface_monitor_free(m);
 545     return NULL;
 546 }
 547
 548 void avahi_interface_monitor_sync(AvahiInterfaceMonitor *m) {
 549     assert(m);
 550
 551     while (m->list != LIST_DONE) {
 552         if (!avahi_netlink_work(m->netlink, 1))
 553             break;
 554     }
 555 }
 556
 557 void avahi_interface_monitor_free(AvahiInterfaceMonitor *m) {
 558     assert(m);
 559
 560     while (m->hw_interfaces)
 561         free_hw_interface(m, m->hw_interfaces, 1);
 562
 563     assert(!m->interfaces);
 564
 565
 566     if (m->netlink)
 567         avahi_netlink_free(m->netlink);
 568
 569     if (m->hashmap)
 570         avahi_hashmap_free(m->hashmap);
 571
 572     avahi_free(m);
 573 }
 574
 575
 576 AvahiInterface* avahi_interface_monitor_get_interface(AvahiInterfaceMonitor *m, AvahiIfIndex idx, AvahiProtocol protocol) {
 577     AvahiHwInterface *hw;
 578     AvahiInterface *i;
 579
 580     assert(m);
 581     assert(idx > 0);
 582     assert(protocol != AVAHI_PROTO_UNSPEC);
 583
 584     if (!(hw = avahi_interface_monitor_get_hw_interface(m, idx)))
 585         return NULL;
 586
 587     for (i = hw->interfaces; i; i = i->by_hardware_next)
 588         if (i->protocol == protocol)
 589             return i;
 590
 591     return NULL;
 592 }
 593
 594 AvahiHwInterface* avahi_interface_monitor_get_hw_interface(AvahiInterfaceMonitor *m, AvahiIfIndex idx) {
 595     assert(m);
 596     assert(idx > 0);
 597
 598     return avahi_hashmap_lookup(m->hashmap, &idx);
 599 }
 600
 601 void avahi_interface_send_packet_unicast(AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, uint16_t port) {
 602     assert(i);
 603     assert(p);
 604 /*     char t[64]; */
 605
 606     if (!avahi_interface_relevant(i))
 607         return;
 608
 609     assert(!a || a->family == i->protocol);
 610
 611 /*     if (a) */
 612 /*         avahi_log_debug("unicast sending on '%s.%i' to %s:%u", i->hardware->name, i->protocol, avahi_address_snprint(t, sizeof(t), a), port); */
 613 /*     else */
 614 /*         avahi_log_debug("multicast sending on '%s.%i'", i->hardware->name, i->protocol); */
 615
 616     if (i->protocol == AVAHI_PROTO_INET && i->monitor->server->fd_ipv4 >= 0)
 617         avahi_send_dns_packet_ipv4(i->monitor->server->fd_ipv4, i->hardware->index, p, a ? &a->data.ipv4 : NULL, port);
 618     else if (i->protocol == AVAHI_PROTO_INET6 && i->monitor->server->fd_ipv6 >= 0)
 619         avahi_send_dns_packet_ipv6(i->monitor->server->fd_ipv6, i->hardware->index, p, a ? &a->data.ipv6 : NULL, port);
 620 }
 621
 622 void avahi_interface_send_packet(AvahiInterface *i, AvahiDnsPacket *p) {
 623     assert(i);
 624     assert(p);
 625
 626     avahi_interface_send_packet_unicast(i, p, NULL, 0);
 627 }
 628
 629 int avahi_interface_post_query(AvahiInterface *i, AvahiKey *key, int immediately) {
 630     assert(i);
 631     assert(key);
 632
 633     if (avahi_interface_relevant(i))
 634         return avahi_query_scheduler_post(i->query_scheduler, key, immediately);
 635
 636     return 0;
 637 }
 638
 639 int avahi_interface_post_response(AvahiInterface *i, AvahiRecord *record, int flush_cache, const AvahiAddress *querier, int immediately) {
 640     assert(i);
 641     assert(record);
 642
 643     if (avahi_interface_relevant(i))
 644         return avahi_response_scheduler_post(i->response_scheduler, record, flush_cache, querier, immediately);
 645
 646     return 0;
 647 }
 648
 649 int avahi_interface_post_probe(AvahiInterface *i, AvahiRecord *record, int immediately) {
 650     assert(i);
 651     assert(record);
 652
 653     if (avahi_interface_relevant(i))
 654         return avahi_probe_scheduler_post(i->probe_scheduler, record, immediately);
 655
 656     return 0;
 657 }
 658
 659 int avahi_dump_caches(AvahiInterfaceMonitor *m, AvahiDumpCallback callback, void* userdata) {
 660     AvahiInterface *i;
 661     assert(m);
 662
 663     for (i = m->interfaces; i; i = i->interface_next) {
 664         if (avahi_interface_relevant(i)) {
 665             char ln[256];
 666             snprintf(ln, sizeof(ln), ";;; INTERFACE %s.%i ;;;", i->hardware->name, i->protocol);
 667             callback(ln, userdata);
 668             if (avahi_cache_dump(i->cache, callback, userdata) < 0)
 669                 return -1;
 670         }
 671     }
 672
 673     return 0;
 674 }
 675
 676 int avahi_interface_relevant(AvahiInterface *i) {
 677     AvahiInterfaceAddress *a;
 678     int relevant_address;
 679
 680     assert(i);
 681
 682     relevant_address = 0;
 683
 684     for (a = i->addresses; a; a = a->address_next)
 685         if (avahi_interface_address_relevant(a)) {
 686             relevant_address = 1;
 687             break;
 688         }
 689
 690 /*     avahi_log_debug("%p. iface-relevant: %i %i %i %i %i %i", i, relevant_address, */
 691 /*               (i->hardware->flags & IFF_UP), */
 692 /*               (i->hardware->flags & IFF_RUNNING), */
 693 /*               !(i->hardware->flags & IFF_LOOPBACK), */
 694 /*               (i->hardware->flags & IFF_MULTICAST), */
 695 /*               !(i->hardware->flags & IFF_POINTOPOINT)); */
 696
 697     return
 698         (i->hardware->flags & IFF_UP) &&
 699         (!i->monitor->server->config.use_iff_running || (i->hardware->flags & IFF_RUNNING)) &&
 700         !(i->hardware->flags & IFF_LOOPBACK) &&
 701         (i->hardware->flags & IFF_MULTICAST) &&
 702         !(i->hardware->flags & IFF_POINTOPOINT) &&
 703         relevant_address;
 704 }
 705
 706 int avahi_interface_address_relevant(AvahiInterfaceAddress *a) {
 707     assert(a);
 708
 709     return a->scope == RT_SCOPE_UNIVERSE;
 710 }
 711
 712
 713 int avahi_interface_match(AvahiInterface *i, AvahiIfIndex idx, AvahiProtocol protocol) {
 714     assert(i);
 715
 716     if (idx > 0 && idx != i->hardware->index)
 717         return 0;
 718
 719     if (protocol != AVAHI_PROTO_UNSPEC && protocol != i->protocol)
 720         return 0;
 721
 722     return 1;
 723 }
 724
 725 void avahi_interface_monitor_walk(AvahiInterfaceMonitor *m, AvahiIfIndex interface, AvahiProtocol protocol, AvahiInterfaceMonitorWalkCallback callback, void* userdata) {
 726     assert(m);
 727     assert(callback);
 728
 729     if (interface > 0) {
 730         if (protocol != AVAHI_PROTO_UNSPEC) {
 731             AvahiInterface *i;
 732
 733             if ((i = avahi_interface_monitor_get_interface(m, interface, protocol)))
 734                 callback(m, i, userdata);
 735
 736         } else {
 737             AvahiHwInterface *hw;
 738             AvahiInterface *i;
 739
 740             if ((hw = avahi_interface_monitor_get_hw_interface(m, interface)))
 741                 for (i = hw->interfaces; i; i = i->by_hardware_next)
 742                     if (avahi_interface_match(i, interface, protocol))
 743                         callback(m, i, userdata);
 744         }
 745
 746     } else {
 747         AvahiInterface *i;
 748
 749         for (i = m->interfaces; i; i = i->interface_next)
 750             if (avahi_interface_match(i, interface, protocol))
 751                 callback(m, i, userdata);
 752     }
 753 }
 754
 755 void avahi_update_host_rrs(AvahiInterfaceMonitor *m, int remove_rrs) {
 756     AvahiHwInterface *hw;
 757
 758     assert(m);
 759
 760     for (hw = m->hw_interfaces; hw; hw = hw->hardware_next)
 761         update_hw_interface_rr(m, hw, remove_rrs);
 762 }
 763
 764 int avahi_address_is_local(AvahiInterfaceMonitor *m, const AvahiAddress *a) {
 765     AvahiInterface *i;
 766     AvahiInterfaceAddress *ia;
 767     assert(m);
 768     assert(a);
 769
 770     for (i = m->interfaces; i; i = i->interface_next)
 771         for (ia = i->addresses; ia; ia = ia->address_next)
 772             if (avahi_address_cmp(a, &ia->address) == 0)
 773                 return 1;
 774
 775     return 0;
 776 }
 777
 778 int avahi_interface_address_on_link(AvahiInterface *i, const AvahiAddress *a) {
 779     AvahiInterfaceAddress *ia;
 780
 781     assert(i);
 782     assert(a);
 783
 784     if (a->family != i->protocol)
 785         return 0;
 786
 787     for (ia = i->addresses; ia; ia = ia->address_next) {
 788
 789         if (a->family == AVAHI_PROTO_INET) {
 790             uint32_t m;
 791
 792             m = ~(((uint32_t) -1) >> ia->prefix_len);
 793
 794             if ((ntohl(a->data.ipv4.address) & m) == (ntohl(ia->address.data.ipv4.address) & m))
 795                 return 1;
 796         } else {
 797             unsigned j;
 798             unsigned char pl;
 799             assert(a->family == AVAHI_PROTO_INET6);
 800
 801             pl = ia->prefix_len;
 802
 803             for (j = 0; j < 16; j++) {
 804                 uint8_t m;
 805
 806                 if (pl == 0)
 807                     return 1;
 808
 809                 if (pl >= 8) {
 810                     m = 0xFF;
 811                     pl -= 8;
 812                 } else {
 813                     m = ~(0xFF >> pl);
 814                     pl = 0;
 815                 }
 816
 817                 if ((a->data.ipv6.address[j] & m) != (ia->address.data.ipv6.address[j] & m))
 818                     break;
 819             }
 820         }
 821     }
 822
 823     return 0;
 824 }