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