2 #include <sys/socket.h>
4 #include <linux/netlink.h>
5 #include <linux/rtnetlink.h>
15 static void update_address_rr(flxInterfaceMonitor *m, flxInterfaceAddress *a, int remove) {
19 if (!flx_interface_address_relevant(a) || remove) {
21 flx_server_remove(m->server, a->rr_id);
26 a->rr_id = flx_server_get_next_id(m->server);
27 flx_server_add_address(m->server, a->rr_id, a->interface->hardware->index, AF_UNSPEC, FALSE, m->server->hostname, &a->address);
32 static void update_interface_rr(flxInterfaceMonitor *m, flxInterface *i, int remove) {
33 flxInterfaceAddress *a;
37 for (a = i->addresses; a; a = a->address_next)
38 update_address_rr(m, a, remove);
41 static void update_hw_interface_rr(flxInterfaceMonitor *m, flxHwInterface *hw, int remove) {
47 for (i = hw->interfaces; i; i = i->by_hardware_next)
48 update_interface_rr(m, i, remove);
51 static void free_address(flxInterfaceMonitor *m, flxInterfaceAddress *a) {
54 g_assert(a->interface);
56 FLX_LLIST_REMOVE(flxInterfaceAddress, address, a->interface->addresses, a);
57 flx_server_remove(m->server, a->rr_id);
62 static void free_interface(flxInterfaceMonitor *m, flxInterface *i, gboolean send_goodbye) {
66 g_message("removing interface %s.%i", i->hardware->name, i->protocol);
67 flx_goodbye_interface(m->server, i, send_goodbye);
68 g_message("flushing...");
69 flx_packet_scheduler_flush_responses(i->scheduler);
72 g_assert(!i->announcements);
75 free_address(m, i->addresses);
77 flx_packet_scheduler_free(i->scheduler);
78 flx_cache_free(i->cache);
80 FLX_LLIST_REMOVE(flxInterface, interface, m->interfaces, i);
81 FLX_LLIST_REMOVE(flxInterface, by_hardware, i->hardware->interfaces, i);
86 static void free_hw_interface(flxInterfaceMonitor *m, flxHwInterface *hw, gboolean send_goodbye) {
90 while (hw->interfaces)
91 free_interface(m, hw->interfaces, send_goodbye);
93 FLX_LLIST_REMOVE(flxHwInterface, hardware, m->hw_interfaces, hw);
94 g_hash_table_remove(m->hash_table, &hw->index);
100 static flxInterfaceAddress* get_address(flxInterfaceMonitor *m, flxInterface *i, const flxAddress *raddr) {
101 flxInterfaceAddress *ia;
107 for (ia = i->addresses; ia; ia = ia->address_next)
108 if (flx_address_cmp(&ia->address, raddr) == 0)
114 static int netlink_list_items(flxNetlink *nl, guint16 type, guint *ret_seq) {
116 struct rtgenmsg *gen;
119 memset(&req, 0, sizeof(req));
120 n = (struct nlmsghdr*) req;
121 n->nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
122 n->nlmsg_type = type;
123 n->nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
127 memset(gen, 0, sizeof(struct rtgenmsg));
128 gen->rtgen_family = AF_UNSPEC;
130 return flx_netlink_send(nl, n, ret_seq);
133 static void new_interface(flxInterfaceMonitor *m, flxHwInterface *hw, guchar protocol) {
138 g_assert(protocol != AF_UNSPEC);
140 i = g_new(flxInterface, 1);
143 i->protocol = protocol;
144 i->announcing = FALSE;
146 FLX_LLIST_HEAD_INIT(flxInterfaceAddress, i->addresses);
147 FLX_LLIST_HEAD_INIT(flxAnnouncement, i->announcements);
149 i->cache = flx_cache_new(m->server, i);
150 i->scheduler = flx_packet_scheduler_new(m->server, i);
152 FLX_LLIST_PREPEND(flxInterface, by_hardware, hw->interfaces, i);
153 FLX_LLIST_PREPEND(flxInterface, interface, m->interfaces, i);
156 static void check_interface_relevant(flxInterfaceMonitor *m, flxInterface *i) {
161 b = flx_interface_relevant(i);
163 if (b && !i->announcing) {
164 g_message("New relevant interface %s.%i", i->hardware->name, i->protocol);
166 i->announcing = TRUE;
167 flx_announce_interface(m->server, i);
168 } else if (!b && i->announcing) {
169 g_message("Interface %s.%i no longer relevant", i->hardware->name, i->protocol);
171 i->announcing = FALSE;
172 flx_goodbye_interface(m->server, i, FALSE);
176 static void check_hw_interface_relevant(flxInterfaceMonitor *m, flxHwInterface *hw) {
182 for (i = hw->interfaces; i; i = i->by_hardware_next)
183 check_interface_relevant(m, i);
186 static void callback(flxNetlink *nl, struct nlmsghdr *n, gpointer userdata) {
187 flxInterfaceMonitor *m = userdata;
191 g_assert(m->netlink == nl);
193 if (n->nlmsg_type == RTM_NEWLINK) {
194 struct ifinfomsg *ifinfomsg = NLMSG_DATA(n);
196 struct rtattr *a = NULL;
199 if (ifinfomsg->ifi_family != AF_UNSPEC)
202 if (!(hw = g_hash_table_lookup(m->hash_table, &ifinfomsg->ifi_index))) {
203 hw = g_new(flxHwInterface, 1);
208 hw->index = ifinfomsg->ifi_index;
210 FLX_LLIST_HEAD_INIT(flxInterface, hw->interfaces);
211 FLX_LLIST_PREPEND(flxHwInterface, hardware, m->hw_interfaces, hw);
213 g_hash_table_insert(m->hash_table, &hw->index, hw);
215 if (m->server->fd_ipv4 >= 0)
216 new_interface(m, hw, AF_INET);
217 if (m->server->fd_ipv6 >= 0)
218 new_interface(m, hw, AF_INET6);
221 hw->flags = ifinfomsg->ifi_flags;
223 l = NLMSG_PAYLOAD(n, sizeof(struct ifinfomsg));
224 a = IFLA_RTA(ifinfomsg);
226 while (RTA_OK(a, l)) {
227 switch(a->rta_type) {
230 hw->name = g_strndup(RTA_DATA(a), RTA_PAYLOAD(a));
234 g_assert(RTA_PAYLOAD(a) == sizeof(unsigned int));
235 hw->mtu = *((unsigned int*) RTA_DATA(a));
245 update_hw_interface_rr(m, hw, FALSE);
246 check_hw_interface_relevant(m, hw);
248 } else if (n->nlmsg_type == RTM_DELLINK) {
249 struct ifinfomsg *ifinfomsg = NLMSG_DATA(n);
253 if (ifinfomsg->ifi_family != AF_UNSPEC)
256 if (!(hw = flx_interface_monitor_get_hw_interface(m, ifinfomsg->ifi_index)))
259 update_hw_interface_rr(m, hw, TRUE);
260 free_hw_interface(m, hw, FALSE);
262 } else if (n->nlmsg_type == RTM_NEWADDR || n->nlmsg_type == RTM_DELADDR) {
264 struct ifaddrmsg *ifaddrmsg = NLMSG_DATA(n);
266 struct rtattr *a = NULL;
271 if (ifaddrmsg->ifa_family != AF_INET && ifaddrmsg->ifa_family != AF_INET6)
274 if (!(i = (flxInterface*) flx_interface_monitor_get_interface(m, ifaddrmsg->ifa_index, ifaddrmsg->ifa_family)))
277 raddr.family = ifaddrmsg->ifa_family;
279 l = NLMSG_PAYLOAD(n, sizeof(struct ifinfomsg));
280 a = IFA_RTA(ifaddrmsg);
282 while (RTA_OK(a, l)) {
283 switch(a->rta_type) {
285 if ((raddr.family == AF_INET6 && RTA_PAYLOAD(a) != 16) ||
286 (raddr.family == AF_INET && RTA_PAYLOAD(a) != 4))
289 memcpy(raddr.data.data, RTA_DATA(a), RTA_PAYLOAD(a));
305 if (n->nlmsg_type == RTM_NEWADDR) {
306 flxInterfaceAddress *addr;
308 if (!(addr = get_address(m, i, &raddr))) {
309 addr = g_new(flxInterfaceAddress, 1);
311 addr->address = raddr;
315 FLX_LLIST_PREPEND(flxInterfaceAddress, address, i->addresses, addr);
318 addr->flags = ifaddrmsg->ifa_flags;
319 addr->scope = ifaddrmsg->ifa_scope;
321 update_address_rr(m, addr, FALSE);
322 check_interface_relevant(m, i);
324 flxInterfaceAddress *addr;
326 if (!(addr = get_address(m, i, &raddr)))
329 update_address_rr(m, addr, TRUE);
330 free_address(m, addr);
332 check_interface_relevant(m, i);
335 } else if (n->nlmsg_type == NLMSG_DONE) {
337 if (m->list == LIST_IFACE) {
340 if (netlink_list_items(m->netlink, RTM_GETADDR, &m->query_addr_seq) < 0)
341 g_warning("NETLINK: Failed to list addrs: %s", strerror(errno));
346 g_message("Enumeration complete");
349 } else if (n->nlmsg_type == NLMSG_ERROR && (n->nlmsg_seq == m->query_link_seq || n->nlmsg_seq == m->query_addr_seq)) {
350 struct nlmsgerr *e = NLMSG_DATA (n);
353 g_warning("NETLINK: Failed to browse: %s", strerror(-e->error));
357 flxInterfaceMonitor *flx_interface_monitor_new(flxServer *s) {
358 flxInterfaceMonitor *m = NULL;
360 m = g_new0(flxInterfaceMonitor, 1);
362 if (!(m->netlink = flx_netlink_new(s->context, RTMGRP_LINK|RTMGRP_IPV4_IFADDR|RTMGRP_IPV6_IFADDR, callback, m)))
365 m->hash_table = g_hash_table_new(g_int_hash, g_int_equal);
367 FLX_LLIST_HEAD_INIT(flxInterface, m->interfaces);
368 FLX_LLIST_HEAD_INIT(flxHwInterface, m->hw_interfaces);
370 if (netlink_list_items(m->netlink, RTM_GETLINK, &m->query_link_seq) < 0)
373 m->list = LIST_IFACE;
378 flx_interface_monitor_free(m);
382 void flx_interface_monitor_free(flxInterfaceMonitor *m) {
385 while (m->hw_interfaces)
386 free_hw_interface(m, m->hw_interfaces, TRUE);
388 g_assert(!m->interfaces);
392 flx_netlink_free(m->netlink);
395 g_hash_table_destroy(m->hash_table);
401 flxInterface* flx_interface_monitor_get_interface(flxInterfaceMonitor *m, gint index, guchar protocol) {
407 g_assert(protocol != AF_UNSPEC);
409 if (!(hw = flx_interface_monitor_get_hw_interface(m, index)))
412 for (i = hw->interfaces; i; i = i->by_hardware_next)
413 if (i->protocol == protocol)
419 flxHwInterface* flx_interface_monitor_get_hw_interface(flxInterfaceMonitor *m, gint index) {
423 return g_hash_table_lookup(m->hash_table, &index);
427 void flx_interface_send_packet(flxInterface *i, flxDnsPacket *p) {
431 if (flx_interface_relevant(i)) {
432 g_message("sending on '%s.%i'", i->hardware->name, i->protocol);
434 if (i->protocol == AF_INET && i->monitor->server->fd_ipv4 >= 0)
435 flx_send_dns_packet_ipv4(i->monitor->server->fd_ipv4, i->hardware->index, p);
436 else if (i->protocol == AF_INET6 && i->monitor->server->fd_ipv6 >= 0)
437 flx_send_dns_packet_ipv6(i->monitor->server->fd_ipv6, i->hardware->index, p);
441 void flx_interface_post_query(flxInterface *i, flxKey *key, gboolean immediately) {
445 if (flx_interface_relevant(i))
446 flx_packet_scheduler_post_query(i->scheduler, key, immediately);
450 void flx_interface_post_response(flxInterface *i, const flxAddress *a, flxRecord *record, gboolean immediately) {
454 if (flx_interface_relevant(i))
455 flx_packet_scheduler_post_response(i->scheduler, a, record, immediately);
458 void flx_dump_caches(flxInterfaceMonitor *m, FILE *f) {
462 for (i = m->interfaces; i; i = i->interface_next) {
463 if (flx_interface_relevant(i)) {
464 fprintf(f, "\n;;; INTERFACE %s.%i ;;;\n", i->hardware->name, i->protocol);
465 flx_cache_dump(i->cache, f);
471 gboolean flx_interface_relevant(flxInterface *i) {
475 (i->hardware->flags & IFF_UP) &&
476 (i->hardware->flags & IFF_RUNNING) &&
477 !(i->hardware->flags & IFF_LOOPBACK) &&
478 (i->hardware->flags & IFF_MULTICAST) &&
482 gboolean flx_interface_address_relevant(flxInterfaceAddress *a) {
485 return a->scope == RT_SCOPE_UNIVERSE;
489 gboolean flx_interface_match(flxInterface *i, gint index, guchar protocol) {
492 if (index > 0 && index != i->hardware->index)
495 if (protocol != AF_UNSPEC && protocol != i->protocol)
502 void flx_interface_monitor_walk(flxInterfaceMonitor *m, gint interface, guchar protocol, flxInterfaceMonitorWalkCallback callback, gpointer userdata) {
507 if (protocol != AF_UNSPEC) {
510 if ((i = flx_interface_monitor_get_interface(m, interface, protocol)))
511 callback(m, i, userdata);
517 if ((hw = flx_interface_monitor_get_hw_interface(m, interface)))
518 for (i = hw->interfaces; i; i = i->by_hardware_next)
519 if (flx_interface_match(i, interface, protocol))
520 callback(m, i, userdata);
526 for (i = m->interfaces; i; i = i->interface_next)
527 if (flx_interface_match(i, interface, protocol))
528 callback(m, i, userdata);