1/* vi: set sw=4 ts=4: */
2/*
3 * libnetlink.c	RTnetlink service routines.
4 *
5 *		This program is free software; you can redistribute it and/or
6 *		modify it under the terms of the GNU General Public License
7 *		as published by the Free Software Foundation; either version
8 *		2 of the License, or (at your option) any later version.
9 *
10 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
11 *
12 */
13
14#include <sys/socket.h>
15#include <sys/uio.h>
16
17#include "libbb.h"
18#include "libnetlink.h"
19
20void rtnl_close(struct rtnl_handle *rth)
21{
22	close(rth->fd);
23}
24
25int xrtnl_open(struct rtnl_handle *rth/*, unsigned subscriptions*/)
26{
27	socklen_t addr_len;
28
29	memset(rth, 0, sizeof(rth));
30
31	rth->fd = xsocket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
32
33	memset(&rth->local, 0, sizeof(rth->local));
34	rth->local.nl_family = AF_NETLINK;
35	/*rth->local.nl_groups = subscriptions;*/
36
37	xbind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local));
38	addr_len = sizeof(rth->local);
39	if (getsockname(rth->fd, (struct sockaddr*)&rth->local, &addr_len) < 0)
40		bb_perror_msg_and_die("cannot getsockname");
41	if (addr_len != sizeof(rth->local))
42		bb_error_msg_and_die("wrong address length %d", addr_len);
43	if (rth->local.nl_family != AF_NETLINK)
44		bb_error_msg_and_die("wrong address family %d", rth->local.nl_family);
45	rth->seq = time(NULL);
46	return 0;
47}
48
49int xrtnl_wilddump_request(struct rtnl_handle *rth, int family, int type)
50{
51	struct {
52		struct nlmsghdr nlh;
53		struct rtgenmsg g;
54	} req;
55	struct sockaddr_nl nladdr;
56
57	memset(&nladdr, 0, sizeof(nladdr));
58	nladdr.nl_family = AF_NETLINK;
59
60	req.nlh.nlmsg_len = sizeof(req);
61	req.nlh.nlmsg_type = type;
62	req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
63	req.nlh.nlmsg_pid = 0;
64	req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
65	req.g.rtgen_family = family;
66
67	return xsendto(rth->fd, (void*)&req, sizeof(req),
68				 (struct sockaddr*)&nladdr, sizeof(nladdr));
69}
70
71int rtnl_send(struct rtnl_handle *rth, char *buf, int len)
72{
73	struct sockaddr_nl nladdr;
74
75	memset(&nladdr, 0, sizeof(nladdr));
76	nladdr.nl_family = AF_NETLINK;
77
78	return xsendto(rth->fd, buf, len, (struct sockaddr*)&nladdr, sizeof(nladdr));
79}
80
81int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len)
82{
83	struct nlmsghdr nlh;
84	struct sockaddr_nl nladdr;
85	struct iovec iov[2] = { { &nlh, sizeof(nlh) }, { req, len } };
86	struct msghdr msg = {
87		(void*)&nladdr, sizeof(nladdr),
88		iov,	2,
89		NULL,	0,
90		0
91	};
92
93	memset(&nladdr, 0, sizeof(nladdr));
94	nladdr.nl_family = AF_NETLINK;
95
96	nlh.nlmsg_len = NLMSG_LENGTH(len);
97	nlh.nlmsg_type = type;
98	nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
99	nlh.nlmsg_pid = 0;
100	nlh.nlmsg_seq = rth->dump = ++rth->seq;
101
102	return sendmsg(rth->fd, &msg, 0);
103}
104
105static int rtnl_dump_filter(struct rtnl_handle *rth,
106		int (*filter)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
107		void *arg1/*,
108		int (*junk)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
109		void *arg2*/)
110{
111	char buf[8192];
112	struct sockaddr_nl nladdr;
113	struct iovec iov = { buf, sizeof(buf) };
114
115	while (1) {
116		int status;
117		struct nlmsghdr *h;
118
119		struct msghdr msg = {
120			(void*)&nladdr, sizeof(nladdr),
121			&iov,	1,
122			NULL,	0,
123			0
124		};
125
126		status = recvmsg(rth->fd, &msg, 0);
127
128		if (status < 0) {
129			if (errno == EINTR)
130				continue;
131			bb_perror_msg("OVERRUN");
132			continue;
133		}
134		if (status == 0) {
135			bb_error_msg("EOF on netlink");
136			return -1;
137		}
138		if (msg.msg_namelen != sizeof(nladdr)) {
139			bb_error_msg_and_die("sender address length == %d", msg.msg_namelen);
140		}
141
142		h = (struct nlmsghdr*)buf;
143		while (NLMSG_OK(h, status)) {
144			int err;
145
146			if (nladdr.nl_pid != 0 ||
147			    h->nlmsg_pid != rth->local.nl_pid ||
148			    h->nlmsg_seq != rth->dump) {
149/*				if (junk) {
150					err = junk(&nladdr, h, arg2);
151					if (err < 0)
152						return err;
153				} */
154				goto skip_it;
155			}
156
157			if (h->nlmsg_type == NLMSG_DONE) {
158				return 0;
159			}
160			if (h->nlmsg_type == NLMSG_ERROR) {
161				struct nlmsgerr *l_err = (struct nlmsgerr*)NLMSG_DATA(h);
162				if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
163					bb_error_msg("ERROR truncated");
164				} else {
165					errno = -l_err->error;
166					bb_perror_msg("RTNETLINK answers");
167				}
168				return -1;
169			}
170			err = filter(&nladdr, h, arg1);
171			if (err < 0)
172				return err;
173
174skip_it:
175			h = NLMSG_NEXT(h, status);
176		}
177		if (msg.msg_flags & MSG_TRUNC) {
178			bb_error_msg("message truncated");
179			continue;
180		}
181		if (status) {
182			bb_error_msg_and_die("remnant of size %d!", status);
183		}
184	}
185}
186
187int xrtnl_dump_filter(struct rtnl_handle *rth,
188		int (*filter)(struct sockaddr_nl *, struct nlmsghdr *n, void *),
189		void *arg1)
190{
191	int ret = rtnl_dump_filter(rth, filter, arg1/*, NULL, NULL*/);
192	if (ret < 0)
193		bb_error_msg_and_die("dump terminated");
194	return ret;
195}
196
197int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
198	      unsigned groups, struct nlmsghdr *answer,
199	      int (*junk)(struct sockaddr_nl *,struct nlmsghdr *n, void *),
200	      void *jarg)
201{
202	int status;
203	unsigned seq;
204	struct nlmsghdr *h;
205	struct sockaddr_nl nladdr;
206	struct iovec iov = { (void*)n, n->nlmsg_len };
207	char   buf[8192];
208	struct msghdr msg = {
209		(void*)&nladdr, sizeof(nladdr),
210		&iov,	1,
211		NULL,	0,
212		0
213	};
214
215	memset(&nladdr, 0, sizeof(nladdr));
216	nladdr.nl_family = AF_NETLINK;
217	nladdr.nl_pid = peer;
218	nladdr.nl_groups = groups;
219
220	n->nlmsg_seq = seq = ++rtnl->seq;
221	if (answer == NULL) {
222		n->nlmsg_flags |= NLM_F_ACK;
223	}
224	status = sendmsg(rtnl->fd, &msg, 0);
225
226	if (status < 0) {
227		bb_perror_msg("cannot talk to rtnetlink");
228		return -1;
229	}
230
231	iov.iov_base = buf;
232
233	while (1) {
234		iov.iov_len = sizeof(buf);
235		status = recvmsg(rtnl->fd, &msg, 0);
236
237		if (status < 0) {
238			if (errno == EINTR) {
239				continue;
240			}
241			bb_perror_msg("OVERRUN");
242			continue;
243		}
244		if (status == 0) {
245			bb_error_msg("EOF on netlink");
246			return -1;
247		}
248		if (msg.msg_namelen != sizeof(nladdr)) {
249			bb_error_msg_and_die("sender address length == %d", msg.msg_namelen);
250		}
251		for (h = (struct nlmsghdr*)buf; status >= sizeof(*h); ) {
252			int l_err;
253			int len = h->nlmsg_len;
254			int l = len - sizeof(*h);
255
256			if (l<0 || len>status) {
257				if (msg.msg_flags & MSG_TRUNC) {
258					bb_error_msg("truncated message");
259					return -1;
260				}
261				bb_error_msg_and_die("malformed message: len=%d!", len);
262			}
263
264			if (nladdr.nl_pid != peer ||
265			    h->nlmsg_pid != rtnl->local.nl_pid ||
266			    h->nlmsg_seq != seq) {
267				if (junk) {
268					l_err = junk(&nladdr, h, jarg);
269					if (l_err < 0) {
270						return l_err;
271					}
272				}
273				continue;
274			}
275
276			if (h->nlmsg_type == NLMSG_ERROR) {
277				struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
278				if (l < sizeof(struct nlmsgerr)) {
279					bb_error_msg("ERROR truncated");
280				} else {
281					errno = -err->error;
282					if (errno == 0) {
283						if (answer) {
284							memcpy(answer, h, h->nlmsg_len);
285						}
286						return 0;
287					}
288					bb_perror_msg("RTNETLINK answers");
289				}
290				return -1;
291			}
292			if (answer) {
293				memcpy(answer, h, h->nlmsg_len);
294				return 0;
295			}
296
297			bb_error_msg("unexpected reply!");
298
299			status -= NLMSG_ALIGN(len);
300			h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));
301		}
302		if (msg.msg_flags & MSG_TRUNC) {
303			bb_error_msg("message truncated");
304			continue;
305		}
306		if (status) {
307			bb_error_msg_and_die("remnant of size %d!", status);
308		}
309	}
310}
311
312int addattr32(struct nlmsghdr *n, int maxlen, int type, uint32_t data)
313{
314	int len = RTA_LENGTH(4);
315	struct rtattr *rta;
316	if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
317		return -1;
318	rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
319	rta->rta_type = type;
320	rta->rta_len = len;
321	memcpy(RTA_DATA(rta), &data, 4);
322	n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
323	return 0;
324}
325
326int addattr_l(struct nlmsghdr *n, int maxlen, int type, void *data, int alen)
327{
328	int len = RTA_LENGTH(alen);
329	struct rtattr *rta;
330
331	if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen)
332		return -1;
333	rta = (struct rtattr*)(((char*)n) + NLMSG_ALIGN(n->nlmsg_len));
334	rta->rta_type = type;
335	rta->rta_len = len;
336	memcpy(RTA_DATA(rta), data, alen);
337	n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
338	return 0;
339}
340
341int rta_addattr32(struct rtattr *rta, int maxlen, int type, uint32_t data)
342{
343	int len = RTA_LENGTH(4);
344	struct rtattr *subrta;
345
346	if (RTA_ALIGN(rta->rta_len) + len > maxlen) {
347		return -1;
348	}
349	subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
350	subrta->rta_type = type;
351	subrta->rta_len = len;
352	memcpy(RTA_DATA(subrta), &data, 4);
353	rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
354	return 0;
355}
356
357int rta_addattr_l(struct rtattr *rta, int maxlen, int type, void *data, int alen)
358{
359	struct rtattr *subrta;
360	int len = RTA_LENGTH(alen);
361
362	if (RTA_ALIGN(rta->rta_len) + len > maxlen) {
363		return -1;
364	}
365	subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
366	subrta->rta_type = type;
367	subrta->rta_len = len;
368	memcpy(RTA_DATA(subrta), data, alen);
369	rta->rta_len = NLMSG_ALIGN(rta->rta_len) + len;
370	return 0;
371}
372
373
374int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len)
375{
376	while (RTA_OK(rta, len)) {
377		if (rta->rta_type <= max) {
378			tb[rta->rta_type] = rta;
379		}
380		rta = RTA_NEXT(rta,len);
381	}
382	if (len) {
383		bb_error_msg("deficit %d, rta_len=%d!", len, rta->rta_len);
384	}
385	return 0;
386}
387