1/* dnsmasq is Copyright (c) 2000-2015 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
38static struct iovec iov;
39static u32 netlink_pid;
40
41static void nl_async(struct nlmsghdr *h);
42
43void 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  addr.nl_groups = RTMGRP_IPV4_ROUTE;
52  if (option_bool(OPT_CLEVERBIND))
53    addr.nl_groups |= RTMGRP_IPV4_IFADDR;
54#ifdef HAVE_IPV6
55  addr.nl_groups |= RTMGRP_IPV6_ROUTE;
56  if (option_bool(OPT_CLEVERBIND))
57    addr.nl_groups |= RTMGRP_IPV6_IFADDR;
58#endif
59#ifdef HAVE_DHCP6
60  if (daemon->doing_ra || daemon->doing_dhcp6)
61    addr.nl_groups |= RTMGRP_IPV6_IFADDR;
62#endif
63
64  /* May not be able to have permission to set multicast groups don't die in that case */
65  if ((daemon->netlinkfd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) != -1)
66    {
67      if (bind(daemon->netlinkfd, (struct sockaddr *)&addr, sizeof(addr)) == -1)
68	{
69	  addr.nl_groups = 0;
70	  if (errno != EPERM || bind(daemon->netlinkfd, (struct sockaddr *)&addr, sizeof(addr)) == -1)
71	    daemon->netlinkfd = -1;
72	}
73    }
74
75  if (daemon->netlinkfd == -1 ||
76      getsockname(daemon->netlinkfd, (struct sockaddr *)&addr, &slen) == 1)
77    die(_("cannot create netlink socket: %s"), NULL, EC_MISC);
78
79  /* save pid assigned by bind() and retrieved by getsockname() */
80  netlink_pid = addr.nl_pid;
81
82  iov.iov_len = 100;
83  iov.iov_base = safe_malloc(iov.iov_len);
84}
85
86static ssize_t netlink_recv(void)
87{
88  struct msghdr msg;
89  struct sockaddr_nl nladdr;
90  ssize_t rc;
91
92  while (1)
93    {
94      msg.msg_control = NULL;
95      msg.msg_controllen = 0;
96      msg.msg_name = &nladdr;
97      msg.msg_namelen = sizeof(nladdr);
98      msg.msg_iov = &iov;
99      msg.msg_iovlen = 1;
100      msg.msg_flags = 0;
101
102      while ((rc = recvmsg(daemon->netlinkfd, &msg, MSG_PEEK | MSG_TRUNC)) == -1 && errno == EINTR);
103
104      /* make buffer big enough */
105      if (rc != -1 && (msg.msg_flags & MSG_TRUNC))
106	{
107	  /* Very new Linux kernels return the actual size needed, older ones always return truncated size */
108	  if ((size_t)rc == iov.iov_len)
109	    {
110	      if (expand_buf(&iov, rc + 100))
111		continue;
112	    }
113	  else
114	    expand_buf(&iov, rc);
115	}
116
117      /* read it for real */
118      msg.msg_flags = 0;
119      while ((rc = recvmsg(daemon->netlinkfd, &msg, 0)) == -1 && errno == EINTR);
120
121      /* Make sure this is from the kernel */
122      if (rc == -1 || nladdr.nl_pid == 0)
123	break;
124    }
125
126  /* discard stuff which is truncated at this point (expand_buf() may fail) */
127  if (msg.msg_flags & MSG_TRUNC)
128    {
129      rc = -1;
130      errno = ENOMEM;
131    }
132
133  return rc;
134}
135
136
137/* family = AF_UNSPEC finds ARP table entries.
138   family = AF_LOCAL finds MAC addresses. */
139int iface_enumerate(int family, void *parm, int (*callback)())
140{
141  struct sockaddr_nl addr;
142  struct nlmsghdr *h;
143  ssize_t len;
144  static unsigned int seq = 0;
145  int callback_ok = 1;
146
147  struct {
148    struct nlmsghdr nlh;
149    struct rtgenmsg g;
150  } req;
151
152  addr.nl_family = AF_NETLINK;
153  addr.nl_pad = 0;
154  addr.nl_groups = 0;
155  addr.nl_pid = 0; /* address to kernel */
156
157 again:
158  if (family == AF_UNSPEC)
159    req.nlh.nlmsg_type = RTM_GETNEIGH;
160  else if (family == AF_LOCAL)
161    req.nlh.nlmsg_type = RTM_GETLINK;
162  else
163    req.nlh.nlmsg_type = RTM_GETADDR;
164
165  req.nlh.nlmsg_len = sizeof(req);
166  req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST | NLM_F_ACK;
167  req.nlh.nlmsg_pid = 0;
168  req.nlh.nlmsg_seq = ++seq;
169  req.g.rtgen_family = family;
170
171  /* Don't block in recvfrom if send fails */
172  while(retry_send(sendto(daemon->netlinkfd, (void *)&req, sizeof(req), 0,
173			  (struct sockaddr *)&addr, sizeof(addr))));
174
175  if (errno != 0)
176    return 0;
177
178  while (1)
179    {
180      if ((len = netlink_recv()) == -1)
181	{
182	  if (errno == ENOBUFS)
183	    {
184	      sleep(1);
185	      goto again;
186	    }
187	  return 0;
188	}
189
190      for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
191	if (h->nlmsg_seq != seq || h->nlmsg_pid != netlink_pid || h->nlmsg_type == NLMSG_ERROR)
192	  {
193	    /* May be multicast arriving async */
194	    nl_async(h);
195	  }
196	else if (h->nlmsg_type == NLMSG_DONE)
197	  return callback_ok;
198	else if (h->nlmsg_type == RTM_NEWADDR && family != AF_UNSPEC && family != AF_LOCAL)
199	  {
200	    struct ifaddrmsg *ifa = NLMSG_DATA(h);
201	    struct rtattr *rta = IFA_RTA(ifa);
202	    unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa));
203
204	    if (ifa->ifa_family == family)
205	      {
206		if (ifa->ifa_family == AF_INET)
207		  {
208		    struct in_addr netmask, addr, broadcast;
209		    char *label = NULL;
210
211		    netmask.s_addr = htonl(~(in_addr_t)0 << (32 - ifa->ifa_prefixlen));
212
213		    addr.s_addr = 0;
214		    broadcast.s_addr = 0;
215
216		    while (RTA_OK(rta, len1))
217		      {
218			if (rta->rta_type == IFA_LOCAL)
219			  addr = *((struct in_addr *)(rta+1));
220			else if (rta->rta_type == IFA_BROADCAST)
221			  broadcast = *((struct in_addr *)(rta+1));
222			else if (rta->rta_type == IFA_LABEL)
223			  label = RTA_DATA(rta);
224
225			rta = RTA_NEXT(rta, len1);
226		      }
227
228		    if (addr.s_addr && callback_ok)
229		      if (!((*callback)(addr, ifa->ifa_index, label,  netmask, broadcast, parm)))
230			callback_ok = 0;
231		  }
232#ifdef HAVE_IPV6
233		else if (ifa->ifa_family == AF_INET6)
234		  {
235		    struct in6_addr *addrp = NULL;
236		    u32 valid = 0, preferred = 0;
237		    int flags = 0;
238
239		    while (RTA_OK(rta, len1))
240		      {
241			if (rta->rta_type == IFA_ADDRESS)
242			  addrp = ((struct in6_addr *)(rta+1));
243			else if (rta->rta_type == IFA_CACHEINFO)
244			  {
245			    struct ifa_cacheinfo *ifc = (struct ifa_cacheinfo *)(rta+1);
246			    preferred = ifc->ifa_prefered;
247			    valid = ifc->ifa_valid;
248			  }
249			rta = RTA_NEXT(rta, len1);
250		      }
251
252		    if (ifa->ifa_flags & IFA_F_TENTATIVE)
253		      flags |= IFACE_TENTATIVE;
254
255		    if (ifa->ifa_flags & IFA_F_DEPRECATED)
256		      flags |= IFACE_DEPRECATED;
257
258		    if (!(ifa->ifa_flags & IFA_F_TEMPORARY))
259		      flags |= IFACE_PERMANENT;
260
261		    if (addrp && callback_ok)
262		      if (!((*callback)(addrp, (int)(ifa->ifa_prefixlen), (int)(ifa->ifa_scope),
263					(int)(ifa->ifa_index), flags,
264					(int) preferred, (int)valid, parm)))
265			callback_ok = 0;
266		  }
267#endif
268	      }
269	  }
270	else if (h->nlmsg_type == RTM_NEWNEIGH && family == AF_UNSPEC)
271	  {
272	    struct ndmsg *neigh = NLMSG_DATA(h);
273	    struct rtattr *rta = NDA_RTA(neigh);
274	    unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*neigh));
275	    size_t maclen = 0;
276	    char *inaddr = NULL, *mac = NULL;
277
278	    while (RTA_OK(rta, len1))
279	      {
280		if (rta->rta_type == NDA_DST)
281		  inaddr = (char *)(rta+1);
282		else if (rta->rta_type == NDA_LLADDR)
283		  {
284		    maclen = rta->rta_len - sizeof(struct rtattr);
285		    mac = (char *)(rta+1);
286		  }
287
288		rta = RTA_NEXT(rta, len1);
289	      }
290
291	    if (inaddr && mac && callback_ok)
292	      if (!((*callback)(neigh->ndm_family, inaddr, mac, maclen, parm)))
293		callback_ok = 0;
294	  }
295#ifdef HAVE_DHCP6
296	else if (h->nlmsg_type == RTM_NEWLINK && family == AF_LOCAL)
297	  {
298	    struct ifinfomsg *link =  NLMSG_DATA(h);
299	    struct rtattr *rta = IFLA_RTA(link);
300	    unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*link));
301	    char *mac = NULL;
302	    size_t maclen = 0;
303
304	    while (RTA_OK(rta, len1))
305	      {
306		if (rta->rta_type == IFLA_ADDRESS)
307		  {
308		    maclen = rta->rta_len - sizeof(struct rtattr);
309		    mac = (char *)(rta+1);
310		  }
311
312		rta = RTA_NEXT(rta, len1);
313	      }
314
315	    if (mac && callback_ok && !((link->ifi_flags & (IFF_LOOPBACK | IFF_POINTOPOINT))) &&
316		!((*callback)((int)link->ifi_index, (unsigned int)link->ifi_type, mac, maclen, parm)))
317	      callback_ok = 0;
318	  }
319#endif
320    }
321}
322
323void netlink_multicast(void)
324{
325  ssize_t len;
326  struct nlmsghdr *h;
327  int flags;
328
329  /* don't risk blocking reading netlink messages here. */
330  if ((flags = fcntl(daemon->netlinkfd, F_GETFL)) == -1 ||
331      fcntl(daemon->netlinkfd, F_SETFL, flags | O_NONBLOCK) == -1)
332    return;
333
334  if ((len = netlink_recv()) != -1)
335    for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
336      nl_async(h);
337
338  /* restore non-blocking status */
339  fcntl(daemon->netlinkfd, F_SETFL, flags);
340}
341
342static void nl_async(struct nlmsghdr *h)
343{
344  if (h->nlmsg_type == NLMSG_ERROR)
345    {
346      struct nlmsgerr *err = NLMSG_DATA(h);
347      if (err->error != 0)
348	my_syslog(LOG_ERR, _("netlink returns error: %s"), strerror(-(err->error)));
349    }
350  else if (h->nlmsg_pid == 0 && h->nlmsg_type == RTM_NEWROUTE)
351    {
352      /* We arrange to receive netlink multicast messages whenever the network route is added.
353	 If this happens and we still have a DNS packet in the buffer, we re-send it.
354	 This helps on DoD links, where frequently the packet which triggers dialling is
355	 a DNS query, which then gets lost. By re-sending, we can avoid the lookup
356	 failing. */
357      struct rtmsg *rtm = NLMSG_DATA(h);
358
359      if (rtm->rtm_type == RTN_UNICAST && rtm->rtm_scope == RT_SCOPE_LINK)
360	queue_event(EVENT_NEWROUTE);
361    }
362  else if (h->nlmsg_type == RTM_NEWADDR || h->nlmsg_type == RTM_DELADDR)
363    queue_event(EVENT_NEWADDR);
364}
365#endif
366
367
368