src/netlink.c

   1 /* dnsmasq is Copyright (c) 2000-2011 Simon Kelley
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; version 2 dated June, 1991, or
   6    (at your option) version 3 dated 29 June, 2007.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15 */
  16
  17 #include "dnsmasq.h"
  18
  19 #ifdef HAVE_LINUX_NETWORK
  20
  21 #include <linux/types.h>
  22 #include <linux/netlink.h>
  23 #include <linux/rtnetlink.h>
  24
  25 /* linux 2.6.19 buggers up the headers, patch it up here. */
  26 #ifndef IFA_RTA
  27 #  define IFA_RTA(r)  \
  28        ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))))
  29
  30 #  include <linux/if_addr.h>
  31 #endif
  32
  33 #ifndef NDA_RTA
  34 #  define NDA_RTA(r) ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
  35 #endif
  36
  37 static struct iovec iov;
  38 static u32 netlink_pid;
  39
  40 static void nl_err(struct nlmsghdr *h);
  41 static void nl_routechange(struct nlmsghdr *h);
  42
  43 void netlink_init(void)
  44 {
  45   struct sockaddr_nl addr;
  46   socklen_t slen = sizeof(addr);
  47
  48   addr.nl_family = AF_NETLINK;
  49   addr.nl_pad = 0;
  50   addr.nl_pid = 0; /* autobind */
  51 #ifdef HAVE_IPV6
  52   addr.nl_groups = RTMGRP_IPV4_ROUTE | RTMGRP_IPV6_ROUTE;
  53 #else
  54   addr.nl_groups = RTMGRP_IPV4_ROUTE;
  55 #endif
  56
  57   /* May not be able to have permission to set multicast groups don't die in that case */
  58   if ((daemon->netlinkfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) != -1)
  59     {
  60       if (bind(daemon->netlinkfd, (struct sockaddr *)&addr, sizeof(addr)) == -1)
  61         {
  62           addr.nl_groups = 0;
  63           if (errno != EPERM || bind(daemon->netlinkfd, (struct sockaddr *)&addr, sizeof(addr)) == -1)
  64             daemon->netlinkfd = -1;
  65         }
  66     }
  67
  68   if (daemon->netlinkfd == -1 ||
  69       getsockname(daemon->netlinkfd, (struct sockaddr *)&addr, &slen) == 1)
  70     die(_("cannot create netlink socket: %s"), NULL, EC_MISC);
  71
  72   /* save pid assigned by bind() and retrieved by getsockname() */
  73   netlink_pid = addr.nl_pid;
  74
  75   iov.iov_len = 100;
  76   iov.iov_base = safe_malloc(iov.iov_len);
  77 }
  78
  79 static ssize_t netlink_recv(void)
  80 {
  81   struct msghdr msg;
  82   struct sockaddr_nl nladdr;
  83   ssize_t rc;
  84
  85   while (1)
  86     {
  87       msg.msg_control = NULL;
  88       msg.msg_controllen = 0;
  89       msg.msg_name = &nladdr;
  90       msg.msg_namelen = sizeof(nladdr);
  91       msg.msg_iov = &iov;
  92       msg.msg_iovlen = 1;
  93       msg.msg_flags = 0;
  94
  95       while ((rc = recvmsg(daemon->netlinkfd, &msg, MSG_PEEK | MSG_TRUNC)) == -1 && errno == EINTR);
  96
  97       /* make buffer big enough */
  98       if (rc != -1 && (msg.msg_flags & MSG_TRUNC))
  99         {
 100           /* Very new Linux kernels return the actual size needed, older ones always return truncated size */
 101           if ((size_t)rc == iov.iov_len)
 102             {
 103               if (expand_buf(&iov, rc + 100))
 104                 continue;
 105             }
 106           else
 107             expand_buf(&iov, rc);
 108         }
 109
 110       /* read it for real */
 111       msg.msg_flags = 0;
 112       while ((rc = recvmsg(daemon->netlinkfd, &msg, 0)) == -1 && errno == EINTR);
 113
 114       /* Make sure this is from the kernel */
 115       if (rc == -1 || nladdr.nl_pid == 0)
 116         break;
 117     }
 118
 119   /* discard stuff which is truncated at this point (expand_buf() may fail) */
 120   if (msg.msg_flags & MSG_TRUNC)
 121     {
 122       rc = -1;
 123       errno = ENOMEM;
 124     }
 125
 126   return rc;
 127 }
 128
 129
 130 /* family = AF_UNSPEC finds ARP table entries. */
 131 int iface_enumerate(int family, void *parm, int (*callback)())
 132 {
 133   struct sockaddr_nl addr;
 134   struct nlmsghdr *h;
 135   ssize_t len;
 136   static unsigned int seq = 0;
 137
 138   struct {
 139     struct nlmsghdr nlh;
 140     struct rtgenmsg g;
 141   } req;
 142
 143   addr.nl_family = AF_NETLINK;
 144   addr.nl_pad = 0;
 145   addr.nl_groups = 0;
 146   addr.nl_pid = 0; /* address to kernel */
 147
 148  again:
 149   req.nlh.nlmsg_len = sizeof(req);
 150   req.nlh.nlmsg_type = family == AF_UNSPEC ? RTM_GETNEIGH : RTM_GETADDR;
 151   req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST | NLM_F_ACK;
 152   req.nlh.nlmsg_pid = 0;
 153   req.nlh.nlmsg_seq = ++seq;
 154   req.g.rtgen_family = family;
 155
 156   /* Don't block in recvfrom if send fails */
 157   while((len = sendto(daemon->netlinkfd, (void *)&req, sizeof(req), 0,
 158                       (struct sockaddr *)&addr, sizeof(addr))) == -1 && retry_send());
 159
 160   if (len == -1)
 161     return 0;
 162
 163   while (1)
 164     {
 165       if ((len = netlink_recv()) == -1)
 166         {
 167           if (errno == ENOBUFS)
 168             {
 169               sleep(1);
 170               goto again;
 171             }
 172           return 0;
 173         }
 174
 175       for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
 176         if (h->nlmsg_seq != seq || h->nlmsg_pid != netlink_pid)
 177           nl_routechange(h); /* May be multicast arriving async */
 178         else if (h->nlmsg_type == NLMSG_ERROR)
 179           nl_err(h);
 180         else if (h->nlmsg_type == NLMSG_DONE)
 181           return 1;
 182         else if (h->nlmsg_type == RTM_NEWADDR && family != AF_UNSPEC)
 183           {
 184             struct ifaddrmsg *ifa = NLMSG_DATA(h);
 185             struct rtattr *rta = IFA_RTA(ifa);
 186             unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa));
 187
 188             if (ifa->ifa_family == family)
 189               {
 190                 if (ifa->ifa_family == AF_INET)
 191                   {
 192                     struct in_addr netmask, addr, broadcast;
 193
 194                     netmask.s_addr = htonl(0xffffffff << (32 - ifa->ifa_prefixlen));
 195                     addr.s_addr = 0;
 196                     broadcast.s_addr = 0;
 197
 198                     while (RTA_OK(rta, len1))
 199                       {
 200                         if (rta->rta_type == IFA_LOCAL)
 201                           addr = *((struct in_addr *)(rta+1));
 202                         else if (rta->rta_type == IFA_BROADCAST)
 203                           broadcast = *((struct in_addr *)(rta+1));
 204
 205                         rta = RTA_NEXT(rta, len1);
 206                       }
 207
 208                     if (addr.s_addr)
 209                       if (!((*callback)(addr, ifa->ifa_index, netmask, broadcast, parm)))
 210                         return 0;
 211                   }
 212 #ifdef HAVE_IPV6
 213                 else if (ifa->ifa_family == AF_INET6)
 214                   {
 215                     struct in6_addr *addrp = NULL;
 216                     while (RTA_OK(rta, len1))
 217                       {
 218                         if (rta->rta_type == IFA_ADDRESS)
 219                           addrp = ((struct in6_addr *)(rta+1));
 220
 221                         rta = RTA_NEXT(rta, len1);
 222                       }
 223
 224                     if (addrp)
 225                       if (!((*callback)(addrp, ifa->ifa_index, ifa->ifa_index, parm)))
 226                         return 0;
 227                   }
 228 #endif
 229               }
 230           }
 231         else if (h->nlmsg_type == RTM_NEWNEIGH && family == AF_UNSPEC)
 232           {
 233             struct ndmsg *neigh = NLMSG_DATA(h);
 234             struct rtattr *rta = NDA_RTA(neigh);
 235             unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*neigh));
 236             size_t maclen = 0;
 237             char *inaddr = NULL, *mac = NULL;
 238
 239             while (RTA_OK(rta, len1))
 240               {
 241                 if (rta->rta_type == NDA_DST)
 242                   inaddr = (char *)(rta+1);
 243                 else if (rta->rta_type == NDA_LLADDR)
 244                   {
 245                     maclen = rta->rta_len - sizeof(struct rtattr);
 246                     mac = (char *)(rta+1);
 247                   }
 248
 249                 rta = RTA_NEXT(rta, len1);
 250               }
 251
 252             if (inaddr && mac)
 253               if (!((*callback)(neigh->ndm_family, inaddr, mac, maclen, parm)))
 254                 return 0;
 255           }
 256     }
 257 }
 258
 259 void netlink_multicast(void)
 260 {
 261   ssize_t len;
 262   struct nlmsghdr *h;
 263   int flags;
 264
 265   /* don't risk blocking reading netlink messages here. */
 266   if ((flags = fcntl(daemon->netlinkfd, F_GETFL)) == -1 ||
 267       fcntl(daemon->netlinkfd, F_SETFL, flags | O_NONBLOCK) == -1)
 268     return;
 269
 270   if ((len = netlink_recv()) != -1)
 271     {
 272       for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
 273         if (h->nlmsg_type == NLMSG_ERROR)
 274           nl_err(h);
 275         else
 276           nl_routechange(h);
 277     }
 278
 279   /* restore non-blocking status */
 280   fcntl(daemon->netlinkfd, F_SETFL, flags);
 281 }
 282
 283 static void nl_err(struct nlmsghdr *h)
 284 {
 285   struct nlmsgerr *err = NLMSG_DATA(h);
 286
 287   if (err->error != 0)
 288     my_syslog(LOG_ERR, _("netlink returns error: %s"), strerror(-(err->error)));
 289 }
 290
 291 /* We arrange to receive netlink multicast messages whenever the network route is added.
 292    If this happens and we still have a DNS packet in the buffer, we re-send it.
 293    This helps on DoD links, where frequently the packet which triggers dialling is
 294    a DNS query, which then gets lost. By re-sending, we can avoid the lookup
 295    failing. Note that we only accept these messages from the kernel (pid == 0) */
 296 static void nl_routechange(struct nlmsghdr *h)
 297 {
 298   if (h->nlmsg_pid == 0 && h->nlmsg_type == RTM_NEWROUTE)
 299     {
 300       struct rtmsg *rtm = NLMSG_DATA(h);
 301       int fd;
 302
 303       if (rtm->rtm_type != RTN_UNICAST || rtm->rtm_scope != RT_SCOPE_LINK)
 304         return;
 305
 306       /* Force re-reading resolv file right now, for luck. */
 307       daemon->last_resolv = 0;
 308
 309       if (daemon->srv_save)
 310         {
 311           if (daemon->srv_save->sfd)
 312             fd = daemon->srv_save->sfd->fd;
 313           else if (daemon->rfd_save && daemon->rfd_save->refcount != 0)
 314             fd = daemon->rfd_save->fd;
 315           else
 316             return;
 317
 318           while(sendto(fd, daemon->packet, daemon->packet_len, 0,
 319                        &daemon->srv_save->addr.sa, sa_len(&daemon->srv_save->addr)) == -1 && retry_send());
 320         }
 321     }
 322 }
 323
 324 #endif
 325
 326