]> git.meshlink.io Git - catta/blob - src/iface-pfroute.c
network traffic debug output, including source address on recvmsg
[catta] / src / iface-pfroute.c
1 /***
2   This file is part of catta.
3
4   catta 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   catta 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 catta; 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 <catta/malloc.h>
25
26 #include <string.h>
27 #include <unistd.h>
28 #include <errno.h>
29
30 #include <sys/types.h>
31 #include <sys/socket.h>
32 #include <sys/param.h>
33 #ifdef HAVE_SYS_SYSCTL_H
34 #include <sys/sysctl.h>
35 #else
36 #include <sys/sockio.h>
37 #endif
38
39 #include <net/route.h>
40 #include <net/if.h>
41 #include <net/if_dl.h>
42 #include <netinet/in.h>
43
44 #include <catta/log.h>
45 #include "iface.h"
46 #include "iface-pfroute.h"
47 #include "util.h"
48
49 static int bitcount (unsigned int n)
50 {
51   int count=0 ;
52   while (n)
53     {
54       count++ ;
55       n &= (n - 1) ;
56     }
57   return count ;
58 }
59
60 static void rtm_info(struct rt_msghdr *rtm, CattaInterfaceMonitor *m)
61 {
62   CattaHwInterface *hw;
63   struct if_msghdr *ifm = (struct if_msghdr *)rtm;
64   struct sockaddr_dl *sdl = (struct sockaddr_dl *)(ifm + 1);
65
66   if (sdl->sdl_family != AF_LINK)
67     return;
68
69   if (ifm->ifm_addrs == 0 && ifm->ifm_index > 0) {
70     if (!(hw = catta_interface_monitor_get_hw_interface(m, (CattaIfIndex) ifm->ifm_index)))
71       return;
72     catta_hw_interface_free(hw, 0);
73     return;
74   }
75
76   if (!(hw = catta_interface_monitor_get_hw_interface(m, ifm->ifm_index)))
77     if (!(hw = catta_hw_interface_new(m, (CattaIfIndex) ifm->ifm_index)))
78       return; /* OOM */
79
80   hw->flags_ok =
81     (ifm->ifm_flags & IFF_UP) &&
82     (!m->server->config.use_iff_running || (ifm->ifm_flags & IFF_RUNNING)) &&
83     !(ifm->ifm_flags & IFF_LOOPBACK) &&
84     (ifm->ifm_flags & IFF_MULTICAST) &&
85     (m->server->config.allow_point_to_point || !(ifm->ifm_flags & IFF_POINTOPOINT));
86
87   catta_free(hw->name);
88   hw->name = catta_strndup(sdl->sdl_data, sdl->sdl_nlen);
89
90   hw->mtu = ifm->ifm_data.ifi_mtu;
91
92   hw->mac_address_size = sdl->sdl_alen;
93   if (hw->mac_address_size > CATTA_MAC_ADDRESS_MAX)
94     hw->mac_address_size = CATTA_MAC_ADDRESS_MAX;
95
96   memcpy(hw->mac_address, sdl->sdl_data + sdl->sdl_nlen, hw->mac_address_size);
97
98 /*   { */
99 /*     char mac[256]; */
100 /*     catta_log_debug("======\n name: %s\n index:%d\n mtu:%d\n mac:%s\n flags_ok:%d\n======",  */
101 /*                  hw->name, hw->index,  */
102 /*                  hw->mtu,  */
103 /*                  catta_format_mac_address(mac, sizeof(mac), hw->mac_address, hw->mac_address_size), */
104 /*                  hw->flags_ok); */
105 /*   } */
106
107   catta_hw_interface_check_relevant(hw);
108   catta_hw_interface_update_rrs(hw, 0);
109 }
110
111 #define ROUNDUP(a) \
112      ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
113 #ifdef HAVE_SYS_SYSCTL_H
114 #define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
115 #else
116 #define ADVANCE(x, n) (x += ROUNDUP(sizeof(struct sockaddr)))
117 #endif
118
119 static void rtm_addr(struct rt_msghdr *rtm, CattaInterfaceMonitor *m)
120 {
121   CattaInterface *iface;
122   CattaAddress raddr;
123   int raddr_valid = 0;
124   struct ifa_msghdr *ifam = (struct ifa_msghdr *) rtm;
125   char *cp = (char *)(ifam + 1);
126   char *cp0;
127   int i;
128   int prefixlen = 0;
129   struct sockaddr *sa  =NULL;
130
131 #if defined(__NetBSD__) || defined(__OpenBSD__)
132   if(((struct sockaddr *)cp)->sa_family == AF_UNSPEC)
133     ((struct sockaddr *)cp)->sa_family = AF_INET;
134 #endif
135
136   for (cp0 = cp, i = 0; i < RTAX_MAX; i++) {
137     if (!(ifam->ifam_addrs & (1<<i)))
138       continue;
139     sa = (struct sockaddr *)cp;
140     if (i == RTAX_IFA)
141       break;
142 #ifdef SA_SIZE
143     cp += SA_SIZE(sa);
144 #else
145     ADVANCE(cp, sa);
146 #endif
147   }
148
149   if(sa->sa_family != AF_INET && sa->sa_family != AF_INET6)
150     return;
151
152   if (!(iface = catta_interface_monitor_get_interface(m, (CattaIfIndex) ifam->ifam_index, catta_af_to_proto(sa->sa_family))))
153     return;
154
155   raddr.proto = catta_af_to_proto(sa->sa_family);
156
157   for(cp = cp0, i = 0; i < RTAX_MAX; i++)
158     {
159       if (!(ifam->ifam_addrs & (1<<i)))
160         continue;
161       sa = (struct sockaddr *)cp;
162 #ifdef HAVE_SYS_SYSCTL_H
163       if (sa->sa_len == 0)
164         continue;
165 #endif
166       switch(sa->sa_family) {
167       case AF_INET:
168         switch (1<<i) {
169         case RTA_NETMASK:
170           prefixlen = bitcount((unsigned int)((struct sockaddr_in *)sa)->sin_addr.s_addr);
171           break;
172         case RTA_IFA:
173           memcpy(raddr.data.data, &((struct sockaddr_in *)sa)->sin_addr,  sizeof(struct in_addr));
174           raddr_valid = 1;
175         default:
176           break;
177         }
178         break;
179       case AF_INET6:
180         switch (1<<i) {
181         case RTA_NETMASK:
182           prefixlen = bitcount((unsigned int)((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr);
183           break;
184         case RTA_IFA:
185           memcpy(raddr.data.data, &((struct sockaddr_in6 *)sa)->sin6_addr,  sizeof(struct in6_addr));
186 #ifdef __KAME__
187           if (IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)raddr.data.data))
188             {
189               ((struct in6_addr *)raddr.data.data)->s6_addr[2] = 0;
190               ((struct in6_addr *)raddr.data.data)->s6_addr[3] = 0;
191             }
192 #endif
193           raddr_valid = 1;
194         default:
195           break;
196         }
197         break;
198       default:
199         break;
200       }
201 #ifdef SA_SIZE
202       cp += SA_SIZE(sa);
203 #else
204       ADVANCE(cp, sa);
205 #endif
206     }
207
208   if (!raddr_valid)
209     return;
210
211   if(rtm->rtm_type == RTM_NEWADDR)
212     {
213       CattaInterfaceAddress *addriface;
214       if (!(addriface = catta_interface_monitor_get_address(m, iface, &raddr)))
215         if (!(addriface = catta_interface_address_new(m, iface, &raddr, prefixlen)))
216           return; /* OOM */
217       if (raddr.proto == CATTA_PROTO_INET6)
218         {
219           addriface->global_scope = !(IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)raddr.data.data) || IN6_IS_ADDR_MULTICAST((struct in6_addr *)raddr.data.data));
220         }
221       else
222         addriface->global_scope = 1;
223     }
224   else
225     {
226       CattaInterfaceAddress *addriface;
227       assert(rtm->rtm_type == RTM_DELADDR);
228       if (!(addriface = catta_interface_monitor_get_address(m, iface, &raddr)))
229         return;
230       catta_interface_address_free(addriface);
231     }
232
233   catta_interface_check_relevant(iface);
234   catta_interface_update_rrs(iface, 0);
235 }
236
237 static void parse_rtmsg(struct rt_msghdr *rtm, CattaInterfaceMonitor *m)
238 {
239   assert(m);
240   assert(rtm);
241
242   if (rtm->rtm_version != RTM_VERSION) {
243     catta_log_warn("routing message version %d not understood",
244                    rtm->rtm_version);
245     return;
246   }
247
248   switch (rtm->rtm_type) {
249   case RTM_IFINFO:
250     rtm_info(rtm,m);
251     break;
252   case RTM_NEWADDR:
253   case RTM_DELADDR:
254     rtm_addr(rtm,m);
255     break;
256   default:
257     break;
258   }
259 }
260
261 static void socket_event(CattaWatch *w, int fd, CATTA_GCC_UNUSED CattaWatchEvent event,void *userdata) {
262   CattaInterfaceMonitor *m = (CattaInterfaceMonitor *)userdata;
263   CattaPfRoute *nl = m->osdep.pfroute;
264     ssize_t bytes;
265     char msg[2048];
266
267     assert(m);
268     assert(w);
269     assert(nl);
270     assert(fd == nl->fd);
271
272     do {
273       if((bytes = recv(nl->fd, msg, 2048, MSG_DONTWAIT)) < 0) {
274         if (errno == EAGAIN || errno == EINTR)
275           return;
276         catta_log_error(__FILE__": recv() failed: %s", strerror(errno));
277         return;
278       }
279       parse_rtmsg((struct rt_msghdr *)msg, m);
280     }
281     while (bytes > 0);
282 }
283
284 int catta_interface_monitor_init_osdep(CattaInterfaceMonitor *m) {
285     int fd = -1;
286
287     assert(m);
288
289     m->osdep.pfroute = NULL;
290
291     if ((fd = socket(PF_ROUTE, SOCK_RAW, AF_UNSPEC)) < 0) {
292         catta_log_error(__FILE__": socket(PF_ROUTE): %s", strerror(errno));
293         goto fail;
294     }
295
296     if (!(m->osdep.pfroute = catta_new(CattaPfRoute , 1))) {
297         catta_log_error(__FILE__": catta_new() failed.");
298         goto fail;
299     }
300     m->osdep.pfroute->fd = fd;
301
302     if (!(m->osdep.pfroute->watch = m->server->poll_api->watch_new(m->server->poll_api,
303                                                                    m->osdep.pfroute->fd,
304                                                                    CATTA_WATCH_IN,
305                                                                    socket_event,
306                                                                    m))) {
307       catta_log_error(__FILE__": Failed to create watch.");
308       goto fail;
309     }
310
311     return 0;
312
313 fail:
314
315     if (m->osdep.pfroute) {
316       if (m->osdep.pfroute->watch)
317         m->server->poll_api->watch_free(m->osdep.pfroute->watch);
318
319       if (fd >= 0)
320         close(fd);
321
322       m->osdep.pfroute = NULL;
323     }
324
325     return -1;
326 }
327
328 void catta_interface_monitor_free_osdep(CattaInterfaceMonitor *m) {
329     assert(m);
330
331     if (m->osdep.pfroute) {
332       if (m->osdep.pfroute->watch)
333         m->server->poll_api->watch_free(m->osdep.pfroute->watch);
334
335       if (m->osdep.pfroute->fd >= 0)
336         close(m->osdep.pfroute->fd);
337
338       catta_free(m->osdep.pfroute);
339       m->osdep.pfroute = NULL;
340     }
341 }
342
343 #if defined (SIOCGLIFNUM) && defined(HAVE_STRUCT_LIFCONF) /* Solaris 8 and later; Sol 7? */
344 /*
345  * I got this function from GNU zsbra
346  */
347 static int ip6_masklen (struct in6_addr netmask) {
348     int len = 0;
349     unsigned char val;
350     unsigned char *pnt;
351
352     pnt = (unsigned char *) & netmask;
353
354     while ((*pnt == 0xff) && len < 128) {
355         len += 8;
356         pnt++;
357     }
358
359     if (len < 128) {
360         val = *pnt;
361         while (val) {
362             len++;
363             val <<= 1;
364         }
365     }
366     return len;
367 }
368
369 static void if_add_interface(struct lifreq *lifreq, CattaInterfaceMonitor *m, int fd, int count)
370 {
371     CattaHwInterface *hw;
372     CattaAddress addr;
373     struct lifreq lifrcopy;
374     unsigned int index;
375     int flags;
376     int mtu;
377     int prefixlen;
378     CattaInterfaceAddress *addriface;
379     CattaInterface *iface;
380     struct sockaddr_in mask;
381     struct sockaddr_in6 mask6;
382     char caddr[CATTA_ADDRESS_STR_MAX];
383
384     lifrcopy = *lifreq;
385
386     if (ioctl(fd, SIOCGLIFFLAGS, &lifrcopy) < 0) {
387         catta_log_error(__FILE__": ioctl(SIOCGLIFFLAGS) %s", strerror(errno));
388         return;
389     }
390     flags = lifrcopy.lifr_flags;
391
392     if (ioctl(fd, SIOCGLIFMTU, &lifrcopy) < 0) {
393         catta_log_error(__FILE__": ioctl(SIOCGLIFMTU) %s", strerror(errno));
394         return;
395     }
396     mtu = lifrcopy.lifr_metric;
397
398     if (ioctl(fd, SIOCGLIFADDR, &lifrcopy) < 0) {
399         catta_log_error(__FILE__": ioctl(SIOCGLIFADDR) %s", strerror(errno));
400         return;
401     }
402     addr.proto = catta_af_to_proto(lifreq->lifr_addr.ss_family);
403     if (ioctl(fd, SIOCGLIFNETMASK, &lifrcopy) < 0) {
404         catta_log_error(__FILE__": ioctl(SIOCGLIFNETMASK) %s", strerror(errno));
405         return;
406     }
407     switch (lifreq->lifr_addr.ss_family) {
408         case AF_INET:
409             memcpy(addr.data.data, &((struct sockaddr_in *)&lifreq->lifr_addr)->sin_addr,  sizeof(struct in_addr));
410             memcpy(&mask, &((struct sockaddr_in *)&lifrcopy.lifr_addr)->sin_addr,  sizeof(struct in_addr));
411             prefixlen = bitcount((unsigned int) mask.sin_addr.s_addr);
412             break;
413         case AF_INET6:
414             memcpy(addr.data.data, &((struct sockaddr_in6 *)&lifreq->lifr_addr)->sin6_addr,  sizeof(struct in6_addr));
415             memcpy(&mask6, &((struct sockaddr_in6 *)&lifrcopy.lifr_addr)->sin6_addr,  sizeof(struct in6_addr));
416             prefixlen = lifrcopy.lifr_addrlen;
417             break;
418         default:
419             break;
420     }
421     index = if_nametoindex(lifreq->lifr_name);
422
423     if (!(hw = catta_interface_monitor_get_hw_interface(m, (CattaIfIndex) index))) {
424         if (!(hw = catta_hw_interface_new(m, (CattaIfIndex) index)))
425             return; /* OOM */
426
427         hw->flags_ok =
428             (flags & IFF_UP) &&
429             (!m->server->config.use_iff_running || (flags & IFF_RUNNING)) &&
430             !(flags & IFF_LOOPBACK) &&
431             (flags & IFF_MULTICAST) &&
432             (m->server->config.allow_point_to_point || !(flags & IFF_POINTOPOINT));
433         hw->name = catta_strdup(lifreq->lifr_name);
434         hw->mtu = mtu;
435         /* TODO get mac address */
436     }
437
438     if (!(iface = catta_interface_monitor_get_interface(m, (CattaIfIndex)index, addr.proto)))
439         return;
440
441     if (!(addriface = catta_interface_monitor_get_address(m, iface, &addr)))
442         if (!(addriface = catta_interface_address_new(m, iface, &addr, prefixlen)))
443             return; /* OOM */
444
445     addriface->global_scope = 1;
446
447     catta_hw_interface_check_relevant(hw);
448     catta_hw_interface_update_rrs(hw, 0);
449 }
450 #endif
451
452 void catta_interface_monitor_sync(CattaInterfaceMonitor *m) {
453 #ifndef HAVE_STRUCT_LIFCONF
454   size_t needed;
455   int mib[6];
456   char *buf, *lim, *next, count = 0;
457   struct rt_msghdr *rtm;
458
459   assert(m);
460
461  retry2:
462   mib[0] = CTL_NET;
463   mib[1] = PF_ROUTE;
464   mib[2] = 0;             /* protocol */
465   mib[3] = 0;             /* wildcard address family */
466   mib[4] = NET_RT_IFLIST;
467   mib[5] = 0;             /* no flags */
468   if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
469     {
470       catta_log_error("sysctl failed: %s", strerror(errno));
471       catta_log_error("route-sysctl-estimate");
472       return;
473     }
474   if ((buf = catta_malloc(needed)) == NULL)
475     {
476       catta_log_error("malloc failed in catta_interface_monitor_sync");
477       return;
478     }
479   if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
480     catta_log_warn("sysctl failed: %s", strerror(errno));
481     if (errno == ENOMEM && count++ < 10) {
482       catta_log_warn("Routing table grew, retrying");
483       sleep(1);
484       catta_free(buf);
485       goto retry2;
486     }
487   }
488   lim = buf + needed;
489   for (next = buf; next < lim; next += rtm->rtm_msglen) {
490     rtm = (struct rt_msghdr *)next;
491     parse_rtmsg(rtm, m);
492   }
493
494   m->list_complete = 1;
495   catta_interface_monitor_check_relevant(m);
496   catta_interface_monitor_update_rrs(m, 0);
497   catta_log_info("Network interface enumeration completed.");
498 #elif defined (SIOCGLIFNUM) && defined(HAVE_STRUCT_LIFCONF) /* Solaris 8 and later; Sol 7? */
499     int sockfd;
500     int ret;
501     int n;
502     struct lifnum lifn;
503     struct lifconf lifc;
504     struct lifreq *lifreq;
505
506     if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
507         catta_log_error(__FILE__": socket(PFROUTE): %s", strerror(errno));
508         return;
509     }
510     lifc.lifc_buf = NULL;
511     lifn.lifn_family = AF_UNSPEC;
512     lifn.lifn_flags = 0;
513     if (ioctl(sockfd, SIOCGLIFNUM, &lifn) < 0) {
514         catta_log_error(__FILE__": ioctl(SIOCGLIFNUM): %s", strerror(errno));
515         goto end;
516     }
517     lifc.lifc_len = lifn.lifn_count * sizeof (struct lifreq);
518     if ((lifc.lifc_buf = catta_malloc(lifc.lifc_len)) == NULL) {
519             catta_log_error("malloc failed in catta_interface_monitor_sync");
520             goto end;
521     }
522     lifc.lifc_family = NULL;
523     lifc.lifc_flags = 0;
524     if(ioctl(sockfd, SIOCGLIFCONF, &lifc) < 0) {
525         catta_log_error(__FILE__": ioctl(SIOCGLIFCONF): %s", strerror(errno));
526         goto end;
527     }
528     lifreq = lifc.lifc_req;
529
530     for (n = 0; n < lifc.lifc_len; n += sizeof(struct lifreq)) {
531         if_add_interface(lifreq, m, sockfd, lifn.lifn_count);
532         lifreq++;
533     }
534     m->list_complete = 1;
535     catta_interface_monitor_check_relevant(m);
536     catta_interface_monitor_update_rrs(m, 0);
537 end:
538     close(sockfd);
539     catta_free(lifc.lifc_buf);
540
541     catta_log_info("Network interface enumeration completed.");
542 #endif
543 }