release/src/router/dnsmasq/src/netlink.c

   1 /* dnsmasq is Copyright (c) 2000-2010 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 static struct iovec iov;
  34 static u32 netlink_pid;
  35
  36 static void nl_err(struct nlmsghdr *h);
  37 static void nl_routechange(struct nlmsghdr *h);
  38
  39 void netlink_init(void)
  40 {
  41   struct sockaddr_nl addr;
  42   socklen_t slen = sizeof(addr);
  43
  44   addr.nl_family = AF_NETLINK;
  45   addr.nl_pad = 0;
  46   addr.nl_pid = 0; /* autobind */
  47 #ifdef HAVE_IPV6
  48   addr.nl_groups = RTMGRP_IPV4_ROUTE | RTMGRP_IPV6_ROUTE;
  49 #else
  50   addr.nl_groups = RTMGRP_IPV4_ROUTE;
  51 #endif
  52
  53   /* May not be able to have permission to set multicast groups don't die in that case */
  54   if ((daemon->netlinkfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) != -1)
  55     {
  56       if (bind(daemon->netlinkfd, (struct sockaddr *)&addr, sizeof(addr)) == -1)
  57         {
  58           addr.nl_groups = 0;
  59           if (errno != EPERM || bind(daemon->netlinkfd, (struct sockaddr *)&addr, sizeof(addr)) == -1)
  60             daemon->netlinkfd = -1;
  61         }
  62     }
  63
  64   if (daemon->netlinkfd == -1 ||
  65       getsockname(daemon->netlinkfd, (struct sockaddr *)&addr, &slen) == 1)
  66     die(_("cannot create netlink socket: %s"), NULL, EC_MISC);
  67
  68   /* save pid assigned by bind() and retrieved by getsockname() */
  69   netlink_pid = addr.nl_pid;
  70
  71   iov.iov_len = 100;
  72   iov.iov_base = safe_malloc(iov.iov_len);
  73 }
  74
  75 static ssize_t netlink_recv(void)
  76 {
  77   struct msghdr msg;
  78   struct sockaddr_nl nladdr;
  79   ssize_t rc;
  80
  81   while (1)
  82     {
  83       msg.msg_control = NULL;
  84       msg.msg_controllen = 0;
  85       msg.msg_name = &nladdr;
  86       msg.msg_namelen = sizeof(nladdr);
  87       msg.msg_iov = &iov;
  88       msg.msg_iovlen = 1;
  89       msg.msg_flags = 0;
  90
  91       while ((rc = recvmsg(daemon->netlinkfd, &msg, MSG_PEEK | MSG_TRUNC)) == -1 && errno == EINTR);
  92
  93       /* make buffer big enough */
  94       if (rc != -1 && (msg.msg_flags & MSG_TRUNC))
  95         {
  96           /* Very new Linux kernels return the actual size needed, older ones always return truncated size */
  97           if ((size_t)rc == iov.iov_len)
  98             {
  99               if (expand_buf(&iov, rc + 100))
 100                 continue;
 101             }
 102           else
 103             expand_buf(&iov, rc);
 104         }
 105
 106       /* read it for real */
 107       msg.msg_flags = 0;
 108       while ((rc = recvmsg(daemon->netlinkfd, &msg, 0)) == -1 && errno == EINTR);
 109
 110       /* Make sure this is from the kernel */
 111       if (rc == -1 || nladdr.nl_pid == 0)
 112         break;
 113     }
 114
 115   /* discard stuff which is truncated at this point (expand_buf() may fail) */
 116   if (msg.msg_flags & MSG_TRUNC)
 117     {
 118       rc = -1;
 119       errno = ENOMEM;
 120     }
 121
 122   return rc;
 123 }
 124
 125 int iface_enumerate(void *parm, int (*ipv4_callback)(), int (*ipv6_callback)())
 126 {
 127   struct sockaddr_nl addr;
 128   struct nlmsghdr *h;
 129   ssize_t len;
 130   static unsigned int seq = 0;
 131   int family = AF_INET;
 132
 133   struct {
 134     struct nlmsghdr nlh;
 135     struct rtgenmsg g;
 136   } req;
 137
 138   addr.nl_family = AF_NETLINK;
 139   addr.nl_pad = 0;
 140   addr.nl_groups = 0;
 141   addr.nl_pid = 0; /* address to kernel */
 142
 143  again:
 144   req.nlh.nlmsg_len = sizeof(req);
 145   req.nlh.nlmsg_type = RTM_GETADDR;
 146   req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST | NLM_F_ACK;
 147   req.nlh.nlmsg_pid = 0;
 148   req.nlh.nlmsg_seq = ++seq;
 149   req.g.rtgen_family = family;
 150
 151   /* Don't block in recvfrom if send fails */
 152   while((len = sendto(daemon->netlinkfd, (void *)&req, sizeof(req), 0,
 153                       (struct sockaddr *)&addr, sizeof(addr))) == -1 && retry_send());
 154
 155   if (len == -1)
 156     return 0;
 157
 158   while (1)
 159     {
 160       if ((len = netlink_recv()) == -1)
 161         {
 162           if (errno == ENOBUFS)
 163             {
 164               sleep(1);
 165               goto again;
 166             }
 167           return 0;
 168         }
 169
 170       for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
 171         if (h->nlmsg_seq != seq || h->nlmsg_pid != netlink_pid)
 172           nl_routechange(h); /* May be multicast arriving async */
 173         else if (h->nlmsg_type == NLMSG_ERROR)
 174           nl_err(h);
 175         else if (h->nlmsg_type == NLMSG_DONE)
 176           {
 177 #ifdef HAVE_IPV6
 178             if (family == AF_INET && ipv6_callback)
 179               {
 180                 family = AF_INET6;
 181                 goto again;
 182               }
 183 #endif
 184             return 1;
 185           }
 186         else if (h->nlmsg_type == RTM_NEWADDR)
 187           {
 188             struct ifaddrmsg *ifa = NLMSG_DATA(h);
 189             struct rtattr *rta = IFA_RTA(ifa);
 190             unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa));
 191
 192             if (ifa->ifa_family == AF_INET)
 193               {
 194                 struct in_addr netmask, addr, broadcast;
 195
 196                 netmask.s_addr = htonl(0xffffffff << (32 - ifa->ifa_prefixlen));
 197                 addr.s_addr = 0;
 198                 broadcast.s_addr = 0;
 199
 200                 while (RTA_OK(rta, len1))
 201                   {
 202                     if (rta->rta_type == IFA_LOCAL)
 203                       addr = *((struct in_addr *)(rta+1));
 204                     else if (rta->rta_type == IFA_BROADCAST)
 205                       broadcast = *((struct in_addr *)(rta+1));
 206
 207                     rta = RTA_NEXT(rta, len1);
 208                   }
 209
 210                 if (addr.s_addr && ipv4_callback)
 211                   if (!((*ipv4_callback)(addr, ifa->ifa_index, netmask, broadcast, parm)))
 212                     return 0;
 213               }
 214 #ifdef HAVE_IPV6
 215             else if (ifa->ifa_family == AF_INET6)
 216               {
 217                 struct in6_addr *addrp = NULL;
 218                 while (RTA_OK(rta, len1))
 219                   {
 220                     if (rta->rta_type == IFA_ADDRESS)
 221                       addrp = ((struct in6_addr *)(rta+1));
 222
 223                     rta = RTA_NEXT(rta, len1);
 224                   }
 225
 226                 if (addrp && ipv6_callback)
 227                   if (!((*ipv6_callback)(addrp, ifa->ifa_index, ifa->ifa_index, parm)))
 228                     return 0;
 229               }
 230 #endif
 231           }
 232     }
 233 }
 234
 235
 236 void netlink_multicast(void)
 237 {
 238   ssize_t len;
 239   struct nlmsghdr *h;
 240   int flags;
 241
 242   /* don't risk blocking reading netlink messages here. */
 243   if ((flags = fcntl(daemon->netlinkfd, F_GETFL)) == -1 ||
 244       fcntl(daemon->netlinkfd, F_SETFL, flags | O_NONBLOCK) == -1)
 245     return;
 246
 247   if ((len = netlink_recv()) != -1)
 248     {
 249       for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
 250         if (h->nlmsg_type == NLMSG_ERROR)
 251           nl_err(h);
 252         else
 253           nl_routechange(h);
 254     }
 255
 256   /* restore non-blocking status */
 257   fcntl(daemon->netlinkfd, F_SETFL, flags);
 258 }
 259
 260 static void nl_err(struct nlmsghdr *h)
 261 {
 262   struct nlmsgerr *err = NLMSG_DATA(h);
 263
 264   if (err->error != 0)
 265     my_syslog(LOG_ERR, _("netlink returns error: %s"), strerror(-(err->error)));
 266 }
 267
 268 /* We arrange to receive netlink multicast messages whenever the network route is added.
 269    If this happens and we still have a DNS packet in the buffer, we re-send it.
 270    This helps on DoD links, where frequently the packet which triggers dialling is
 271    a DNS query, which then gets lost. By re-sending, we can avoid the lookup
 272    failing. Note that we only accept these messages from the kernel (pid == 0) */
 273 static void nl_routechange(struct nlmsghdr *h)
 274 {
 275   if (h->nlmsg_pid == 0 && h->nlmsg_type == RTM_NEWROUTE)
 276     {
 277       struct rtmsg *rtm = NLMSG_DATA(h);
 278       int fd;
 279
 280       if (rtm->rtm_type != RTN_UNICAST || rtm->rtm_scope != RT_SCOPE_LINK)
 281         return;
 282
 283       /* Force re-reading resolv file right now, for luck. */
 284       daemon->last_resolv = 0;
 285
 286       if (daemon->srv_save)
 287         {
 288           if (daemon->srv_save->sfd)
 289             fd = daemon->srv_save->sfd->fd;
 290           else if (daemon->rfd_save && daemon->rfd_save->refcount != 0)
 291             fd = daemon->rfd_save->fd;
 292           else
 293             return;
 294
 295           while(sendto(fd, daemon->packet, daemon->packet_len, 0,
 296                        &daemon->srv_save->addr.sa, sa_len(&daemon->srv_save->addr)) == -1 && retry_send());
 297         }
 298     }
 299 }
 300
 301 #endif
 302
 303