Annotation of embedaddon/dnsmasq/src/netlink.c, revision 1.1.1.5
1.1.1.5 ! misho 1: /* dnsmasq is Copyright (c) 2000-2022 Simon Kelley
1.1 misho 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:
1.1.1.4 misho 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:
1.1 misho 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))))
1.1.1.5 ! misho 44: #endif
! 45:
! 46: /* Used to request refresh of addresses or routes just once,
! 47: * when multiple changes might be announced. */
! 48: enum async_states {
! 49: STATE_NEWADDR = (1 << 0),
! 50: STATE_NEWROUTE = (1 << 1),
! 51: };
1.1 misho 52:
53:
54: static struct iovec iov;
55: static u32 netlink_pid;
56:
1.1.1.5 ! misho 57: static unsigned nl_async(struct nlmsghdr *h, unsigned state);
! 58: static void nl_multicast_state(unsigned state);
1.1 misho 59:
1.1.1.4 misho 60: char *netlink_init(void)
1.1 misho 61: {
62: struct sockaddr_nl addr;
63: socklen_t slen = sizeof(addr);
64:
65: addr.nl_family = AF_NETLINK;
66: addr.nl_pad = 0;
67: addr.nl_pid = 0; /* autobind */
68: addr.nl_groups = RTMGRP_IPV4_ROUTE;
1.1.1.5 ! misho 69: addr.nl_groups |= RTMGRP_IPV4_IFADDR;
1.1 misho 70: addr.nl_groups |= RTMGRP_IPV6_ROUTE;
1.1.1.5 ! misho 71: addr.nl_groups |= RTMGRP_IPV6_IFADDR;
1.1.1.4 misho 72:
1.1 misho 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 ||
1.1.1.4 misho 85: getsockname(daemon->netlinkfd, (struct sockaddr *)&addr, &slen) == -1)
1.1 misho 86: die(_("cannot create netlink socket: %s"), NULL, EC_MISC);
1.1.1.4 misho 87:
88:
1.1 misho 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);
1.1.1.4 misho 94:
95: return NULL;
1.1 misho 96: }
97:
1.1.1.5 ! misho 98: static ssize_t netlink_recv(int flags)
1.1 misho 99: {
100: struct msghdr msg;
101: struct sockaddr_nl nladdr;
102: ssize_t rc;
103:
104: while (1)
105: {
106: msg.msg_control = NULL;
107: msg.msg_controllen = 0;
108: msg.msg_name = &nladdr;
109: msg.msg_namelen = sizeof(nladdr);
110: msg.msg_iov = &iov;
111: msg.msg_iovlen = 1;
112: msg.msg_flags = 0;
113:
1.1.1.5 ! misho 114: while ((rc = recvmsg(daemon->netlinkfd, &msg, flags | MSG_PEEK | MSG_TRUNC)) == -1 &&
! 115: errno == EINTR);
1.1 misho 116:
117: /* make buffer big enough */
118: if (rc != -1 && (msg.msg_flags & MSG_TRUNC))
119: {
120: /* Very new Linux kernels return the actual size needed, older ones always return truncated size */
121: if ((size_t)rc == iov.iov_len)
122: {
123: if (expand_buf(&iov, rc + 100))
124: continue;
125: }
126: else
127: expand_buf(&iov, rc);
128: }
129:
130: /* read it for real */
131: msg.msg_flags = 0;
1.1.1.5 ! misho 132: while ((rc = recvmsg(daemon->netlinkfd, &msg, flags)) == -1 && errno == EINTR);
1.1 misho 133:
134: /* Make sure this is from the kernel */
135: if (rc == -1 || nladdr.nl_pid == 0)
136: break;
137: }
138:
139: /* discard stuff which is truncated at this point (expand_buf() may fail) */
140: if (msg.msg_flags & MSG_TRUNC)
141: {
142: rc = -1;
143: errno = ENOMEM;
144: }
145:
146: return rc;
147: }
148:
149:
150: /* family = AF_UNSPEC finds ARP table entries.
1.1.1.5 ! misho 151: family = AF_LOCAL finds MAC addresses.
! 152: returns 0 on failure, 1 on success, -1 when restart is required
! 153: */
1.1 misho 154: int iface_enumerate(int family, void *parm, int (*callback)())
155: {
156: struct sockaddr_nl addr;
157: struct nlmsghdr *h;
158: ssize_t len;
159: static unsigned int seq = 0;
1.1.1.3 misho 160: int callback_ok = 1;
1.1.1.5 ! misho 161: unsigned state = 0;
1.1 misho 162:
163: struct {
164: struct nlmsghdr nlh;
165: struct rtgenmsg g;
166: } req;
167:
1.1.1.4 misho 168: memset(&req, 0, sizeof(req));
169: memset(&addr, 0, sizeof(addr));
170:
1.1 misho 171: addr.nl_family = AF_NETLINK;
172:
173: if (family == AF_UNSPEC)
174: req.nlh.nlmsg_type = RTM_GETNEIGH;
175: else if (family == AF_LOCAL)
176: req.nlh.nlmsg_type = RTM_GETLINK;
177: else
178: req.nlh.nlmsg_type = RTM_GETADDR;
179:
180: req.nlh.nlmsg_len = sizeof(req);
181: req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST | NLM_F_ACK;
182: req.nlh.nlmsg_pid = 0;
183: req.nlh.nlmsg_seq = ++seq;
184: req.g.rtgen_family = family;
185:
186: /* Don't block in recvfrom if send fails */
1.1.1.3 misho 187: while(retry_send(sendto(daemon->netlinkfd, (void *)&req, sizeof(req), 0,
188: (struct sockaddr *)&addr, sizeof(addr))));
189:
190: if (errno != 0)
1.1 misho 191: return 0;
192:
193: while (1)
194: {
1.1.1.5 ! misho 195: if ((len = netlink_recv(0)) == -1)
1.1 misho 196: {
197: if (errno == ENOBUFS)
198: {
1.1.1.5 ! misho 199: nl_multicast_state(state);
! 200: return -1;
1.1 misho 201: }
202: return 0;
203: }
204:
205: for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
1.1.1.4 misho 206: if (h->nlmsg_pid != netlink_pid || h->nlmsg_type == NLMSG_ERROR)
1.1 misho 207: {
208: /* May be multicast arriving async */
1.1.1.5 ! misho 209: state = nl_async(h, state);
1.1 misho 210: }
1.1.1.4 misho 211: else if (h->nlmsg_seq != seq)
212: {
213: /* May be part of incomplete response to previous request after
214: ENOBUFS. Drop it. */
215: continue;
216: }
1.1 misho 217: else if (h->nlmsg_type == NLMSG_DONE)
1.1.1.3 misho 218: return callback_ok;
1.1 misho 219: else if (h->nlmsg_type == RTM_NEWADDR && family != AF_UNSPEC && family != AF_LOCAL)
220: {
221: struct ifaddrmsg *ifa = NLMSG_DATA(h);
222: struct rtattr *rta = IFA_RTA(ifa);
223: unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa));
224:
225: if (ifa->ifa_family == family)
226: {
227: if (ifa->ifa_family == AF_INET)
228: {
229: struct in_addr netmask, addr, broadcast;
1.1.1.2 misho 230: char *label = NULL;
231:
1.1.1.3 misho 232: netmask.s_addr = htonl(~(in_addr_t)0 << (32 - ifa->ifa_prefixlen));
233:
1.1 misho 234: addr.s_addr = 0;
235: broadcast.s_addr = 0;
236:
237: while (RTA_OK(rta, len1))
238: {
239: if (rta->rta_type == IFA_LOCAL)
240: addr = *((struct in_addr *)(rta+1));
241: else if (rta->rta_type == IFA_BROADCAST)
242: broadcast = *((struct in_addr *)(rta+1));
1.1.1.2 misho 243: else if (rta->rta_type == IFA_LABEL)
244: label = RTA_DATA(rta);
1.1 misho 245:
246: rta = RTA_NEXT(rta, len1);
247: }
248:
249: if (addr.s_addr && callback_ok)
1.1.1.2 misho 250: if (!((*callback)(addr, ifa->ifa_index, label, netmask, broadcast, parm)))
1.1 misho 251: callback_ok = 0;
252: }
253: else if (ifa->ifa_family == AF_INET6)
254: {
255: struct in6_addr *addrp = NULL;
256: u32 valid = 0, preferred = 0;
257: int flags = 0;
258:
259: while (RTA_OK(rta, len1))
260: {
1.1.1.5 ! misho 261: /*
! 262: * Important comment: (from if_addr.h)
! 263: * IFA_ADDRESS is prefix address, rather than local interface address.
! 264: * It makes no difference for normally configured broadcast interfaces,
! 265: * but for point-to-point IFA_ADDRESS is DESTINATION address,
! 266: * local address is supplied in IFA_LOCAL attribute.
! 267: */
! 268: if (rta->rta_type == IFA_LOCAL)
! 269: addrp = ((struct in6_addr *)(rta+1));
! 270: else if (rta->rta_type == IFA_ADDRESS && !addrp)
1.1 misho 271: addrp = ((struct in6_addr *)(rta+1));
272: else if (rta->rta_type == IFA_CACHEINFO)
273: {
274: struct ifa_cacheinfo *ifc = (struct ifa_cacheinfo *)(rta+1);
275: preferred = ifc->ifa_prefered;
276: valid = ifc->ifa_valid;
277: }
278: rta = RTA_NEXT(rta, len1);
279: }
280:
281: if (ifa->ifa_flags & IFA_F_TENTATIVE)
282: flags |= IFACE_TENTATIVE;
283:
284: if (ifa->ifa_flags & IFA_F_DEPRECATED)
285: flags |= IFACE_DEPRECATED;
286:
1.1.1.2 misho 287: if (!(ifa->ifa_flags & IFA_F_TEMPORARY))
288: flags |= IFACE_PERMANENT;
289:
1.1 misho 290: if (addrp && callback_ok)
291: if (!((*callback)(addrp, (int)(ifa->ifa_prefixlen), (int)(ifa->ifa_scope),
292: (int)(ifa->ifa_index), flags,
293: (int) preferred, (int)valid, parm)))
294: callback_ok = 0;
295: }
296: }
297: }
298: else if (h->nlmsg_type == RTM_NEWNEIGH && family == AF_UNSPEC)
299: {
300: struct ndmsg *neigh = NLMSG_DATA(h);
301: struct rtattr *rta = NDA_RTA(neigh);
302: unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*neigh));
303: size_t maclen = 0;
304: char *inaddr = NULL, *mac = NULL;
305:
306: while (RTA_OK(rta, len1))
307: {
308: if (rta->rta_type == NDA_DST)
309: inaddr = (char *)(rta+1);
310: else if (rta->rta_type == NDA_LLADDR)
311: {
312: maclen = rta->rta_len - sizeof(struct rtattr);
313: mac = (char *)(rta+1);
314: }
315:
316: rta = RTA_NEXT(rta, len1);
317: }
318:
1.1.1.3 misho 319: if (!(neigh->ndm_state & (NUD_NOARP | NUD_INCOMPLETE | NUD_FAILED)) &&
320: inaddr && mac && callback_ok)
1.1 misho 321: if (!((*callback)(neigh->ndm_family, inaddr, mac, maclen, parm)))
322: callback_ok = 0;
323: }
324: #ifdef HAVE_DHCP6
325: else if (h->nlmsg_type == RTM_NEWLINK && family == AF_LOCAL)
326: {
327: struct ifinfomsg *link = NLMSG_DATA(h);
328: struct rtattr *rta = IFLA_RTA(link);
329: unsigned int len1 = h->nlmsg_len - NLMSG_LENGTH(sizeof(*link));
330: char *mac = NULL;
331: size_t maclen = 0;
332:
333: while (RTA_OK(rta, len1))
334: {
335: if (rta->rta_type == IFLA_ADDRESS)
336: {
337: maclen = rta->rta_len - sizeof(struct rtattr);
338: mac = (char *)(rta+1);
339: }
340:
341: rta = RTA_NEXT(rta, len1);
342: }
343:
344: if (mac && callback_ok && !((link->ifi_flags & (IFF_LOOPBACK | IFF_POINTOPOINT))) &&
345: !((*callback)((int)link->ifi_index, (unsigned int)link->ifi_type, mac, maclen, parm)))
346: callback_ok = 0;
347: }
348: #endif
349: }
350: }
351:
1.1.1.5 ! misho 352: static void nl_multicast_state(unsigned state)
1.1 misho 353: {
354: ssize_t len;
355: struct nlmsghdr *h;
1.1.1.5 ! misho 356:
! 357: do {
! 358: /* don't risk blocking reading netlink messages here. */
! 359: while ((len = netlink_recv(MSG_DONTWAIT)) != -1)
1.1 misho 360:
1.1.1.5 ! misho 361: for (h = (struct nlmsghdr *)iov.iov_base; NLMSG_OK(h, (size_t)len); h = NLMSG_NEXT(h, len))
! 362: state = nl_async(h, state);
! 363: } while (errno == ENOBUFS);
1.1 misho 364: }
365:
1.1.1.5 ! misho 366: void netlink_multicast(void)
! 367: {
! 368: unsigned state = 0;
! 369: nl_multicast_state(state);
! 370: }
! 371:
! 372:
! 373: static unsigned nl_async(struct nlmsghdr *h, unsigned state)
1.1 misho 374: {
375: if (h->nlmsg_type == NLMSG_ERROR)
376: {
377: struct nlmsgerr *err = NLMSG_DATA(h);
378: if (err->error != 0)
379: my_syslog(LOG_ERR, _("netlink returns error: %s"), strerror(-(err->error)));
380: }
1.1.1.5 ! misho 381: else if (h->nlmsg_pid == 0 && h->nlmsg_type == RTM_NEWROUTE &&
! 382: (state & STATE_NEWROUTE)==0)
1.1 misho 383: {
384: /* We arrange to receive netlink multicast messages whenever the network route is added.
385: If this happens and we still have a DNS packet in the buffer, we re-send it.
386: This helps on DoD links, where frequently the packet which triggers dialling is
387: a DNS query, which then gets lost. By re-sending, we can avoid the lookup
388: failing. */
389: struct rtmsg *rtm = NLMSG_DATA(h);
390:
1.1.1.4 misho 391: if (rtm->rtm_type == RTN_UNICAST && rtm->rtm_scope == RT_SCOPE_LINK &&
392: (rtm->rtm_table == RT_TABLE_MAIN ||
393: rtm->rtm_table == RT_TABLE_LOCAL))
1.1.1.5 ! misho 394: {
! 395: queue_event(EVENT_NEWROUTE);
! 396: state |= STATE_NEWROUTE;
! 397: }
! 398: }
! 399: else if ((h->nlmsg_type == RTM_NEWADDR || h->nlmsg_type == RTM_DELADDR) &&
! 400: (state & STATE_NEWADDR)==0)
! 401: {
! 402: queue_event(EVENT_NEWADDR);
! 403: state |= STATE_NEWADDR;
1.1 misho 404: }
1.1.1.5 ! misho 405: return state;
1.1 misho 406: }
1.1.1.5 ! misho 407: #endif /* HAVE_LINUX_NETWORK */
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