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