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