networking/libiproute/iplink.c

/* vi: set sw=4 ts=4: */
/*
 * iplink.c "ip link".
 *
 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
 */
#include <net/if.h>
#include <net/if_packet.h>
#include <netpacket/packet.h>
#include <net/ethernet.h>

#include "ip_common.h"  /* #include "libbb.h" is inside */
#include "rt_names.h"
#include "utils.h"

#ifndef IFLA_LINKINFO
# define IFLA_LINKINFO 18
# define IFLA_INFO_KIND 1
#endif

/* taken from linux/sockios.h */
#define SIOCSIFNAME	0x8923		/* set interface name */

/* Exits on error */
static int get_ctl_fd(void)
{
	int fd;

	fd = socket(PF_INET, SOCK_DGRAM, 0);
	if (fd >= 0)
		return fd;
	fd = socket(PF_PACKET, SOCK_DGRAM, 0);
	if (fd >= 0)
		return fd;
	return xsocket(PF_INET6, SOCK_DGRAM, 0);
}

/* Exits on error */
static void do_chflags(char *dev, uint32_t flags, uint32_t mask)
{
	struct ifreq ifr;
	int fd;

	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
	fd = get_ctl_fd();
	xioctl(fd, SIOCGIFFLAGS, &ifr);
	if ((ifr.ifr_flags ^ flags) & mask) {
		ifr.ifr_flags &= ~mask;
		ifr.ifr_flags |= mask & flags;
		xioctl(fd, SIOCSIFFLAGS, &ifr);
	}
	close(fd);
}

/* Exits on error */
static void do_changename(char *dev, char *newdev)
{
	struct ifreq ifr;
	int fd;

	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
	strncpy_IFNAMSIZ(ifr.ifr_newname, newdev);
	fd = get_ctl_fd();
	xioctl(fd, SIOCSIFNAME, &ifr);
	close(fd);
}

/* Exits on error */
static void set_qlen(char *dev, int qlen)
{
	struct ifreq ifr;
	int s;

	s = get_ctl_fd();
	memset(&ifr, 0, sizeof(ifr));
	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
	ifr.ifr_qlen = qlen;
	xioctl(s, SIOCSIFTXQLEN, &ifr);
	close(s);
}

/* Exits on error */
static void set_mtu(char *dev, int mtu)
{
	struct ifreq ifr;
	int s;

	s = get_ctl_fd();
	memset(&ifr, 0, sizeof(ifr));
	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
	ifr.ifr_mtu = mtu;
	xioctl(s, SIOCSIFMTU, &ifr);
	close(s);
}

/* Exits on error */
static int get_address(char *dev, int *htype)
{
	struct ifreq ifr;
	struct sockaddr_ll me;
	socklen_t alen;
	int s;

	s = xsocket(PF_PACKET, SOCK_DGRAM, 0);

	memset(&ifr, 0, sizeof(ifr));
	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
	xioctl(s, SIOCGIFINDEX, &ifr);

	memset(&me, 0, sizeof(me));
	me.sll_family = AF_PACKET;
	me.sll_ifindex = ifr.ifr_ifindex;
	me.sll_protocol = htons(ETH_P_LOOP);
	xbind(s, (struct sockaddr*)&me, sizeof(me));
	alen = sizeof(me);
	getsockname(s, (struct sockaddr*)&me, &alen);
	//never happens:
	//if (getsockname(s, (struct sockaddr*)&me, &alen) == -1)
	//	bb_perror_msg_and_die("getsockname");
	close(s);
	*htype = me.sll_hatype;
	return me.sll_halen;
}

/* Exits on error */
static void parse_address(char *dev, int hatype, int halen, char *lla, struct ifreq *ifr)
{
	int alen;

	memset(ifr, 0, sizeof(*ifr));
	strncpy_IFNAMSIZ(ifr->ifr_name, dev);
	ifr->ifr_hwaddr.sa_family = hatype;

	alen = hatype == 1/*ARPHRD_ETHER*/ ? 14/*ETH_HLEN*/ : 19/*INFINIBAND_HLEN*/;
	alen = ll_addr_a2n((unsigned char *)(ifr->ifr_hwaddr.sa_data), alen, lla);
	if (alen < 0)
		exit(EXIT_FAILURE);
	if (alen != halen) {
		bb_error_msg_and_die("wrong address (%s) length: expected %d bytes", lla, halen);
	}
}

/* Exits on error */
static void set_address(struct ifreq *ifr, int brd)
{
	int s;

	s = get_ctl_fd();
	if (brd)
		xioctl(s, SIOCSIFHWBROADCAST, ifr);
	else
		xioctl(s, SIOCSIFHWADDR, ifr);
	close(s);
}


static void die_must_be_on_off(const char *msg) NORETURN;
static void die_must_be_on_off(const char *msg)
{
	bb_error_msg_and_die("argument of \"%s\" must be \"on\" or \"off\"", msg);
}

/* Return value becomes exitcode. It's okay to not return at all */
static int do_set(char **argv)
{
	char *dev = NULL;
	uint32_t mask = 0;
	uint32_t flags = 0;
	int qlen = -1;
	int mtu = -1;
	char *newaddr = NULL;
	char *newbrd = NULL;
	struct ifreq ifr0, ifr1;
	char *newname = NULL;
	int htype, halen;
	static const char keywords[] ALIGN1 =
		"up\0""down\0""name\0""mtu\0""qlen\0""multicast\0"
		"arp\0""address\0""dev\0";
	enum { ARG_up = 0, ARG_down, ARG_name, ARG_mtu, ARG_qlen, ARG_multicast,
		ARG_arp, ARG_addr, ARG_dev };
	static const char str_on_off[] ALIGN1 = "on\0""off\0";
	enum { PARM_on = 0, PARM_off };
	smalluint key;

	while (*argv) {
		/* substring search ensures that e.g. "addr" and "address"
		 * are both accepted */
		key = index_in_substrings(keywords, *argv);
		if (key == ARG_up) {
			mask |= IFF_UP;
			flags |= IFF_UP;
		} else if (key == ARG_down) {
			mask |= IFF_UP;
			flags &= ~IFF_UP;
		} else if (key == ARG_name) {
			NEXT_ARG();
			newname = *argv;
		} else if (key == ARG_mtu) {
			NEXT_ARG();
			if (mtu != -1)
				duparg("mtu", *argv);
			mtu = get_unsigned(*argv, "mtu");
		} else if (key == ARG_qlen) {
			NEXT_ARG();
			if (qlen != -1)
				duparg("qlen", *argv);
			qlen = get_unsigned(*argv, "qlen");
		} else if (key == ARG_addr) {
			NEXT_ARG();
			newaddr = *argv;
		} else if (key >= ARG_dev) {
			if (key == ARG_dev) {
				NEXT_ARG();
			}
			if (dev)
				duparg2("dev", *argv);
			dev = *argv;
		} else {
			int param;
			NEXT_ARG();
			param = index_in_strings(str_on_off, *argv);
			if (key == ARG_multicast) {
				if (param < 0)
					die_must_be_on_off("multicast");
				mask |= IFF_MULTICAST;
				if (param == PARM_on)
					flags |= IFF_MULTICAST;
				else
					flags &= ~IFF_MULTICAST;
			} else if (key == ARG_arp) {
				if (param < 0)
					die_must_be_on_off("arp");
				mask |= IFF_NOARP;
				if (param == PARM_on)
					flags &= ~IFF_NOARP;
				else
					flags |= IFF_NOARP;
			}
		}
		argv++;
	}

	if (!dev) {
		bb_error_msg_and_die(bb_msg_requires_arg, "\"dev\"");
	}

	if (newaddr || newbrd) {
		halen = get_address(dev, &htype);
		if (newaddr) {
			parse_address(dev, htype, halen, newaddr, &ifr0);
			set_address(&ifr0, 0);
		}
		if (newbrd) {
			parse_address(dev, htype, halen, newbrd, &ifr1);
			set_address(&ifr1, 1);
		}
	}

	if (newname && strcmp(dev, newname)) {
		do_changename(dev, newname);
		dev = newname;
	}
	if (qlen != -1) {
		set_qlen(dev, qlen);
	}
	if (mtu != -1) {
		set_mtu(dev, mtu);
	}
	if (mask)
		do_chflags(dev, flags, mask);
	return 0;
}

static int ipaddr_list_link(char **argv)
{
	preferred_family = AF_PACKET;
	return ipaddr_list_or_flush(argv, 0);
}

#ifndef NLMSG_TAIL
#define NLMSG_TAIL(nmsg) \
	((struct rtattr *) (((void *) (nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
#endif
/* Return value becomes exitcode. It's okay to not return at all */
static int do_change(char **argv, const unsigned rtm)
{
	static const char keywords[] ALIGN1 =
		"link\0""name\0""type\0""dev\0";
	enum {
		ARG_link,
		ARG_name,
		ARG_type,
		ARG_dev,
	};
	struct rtnl_handle rth;
	struct {
		struct nlmsghdr		n;
		struct ifinfomsg	i;
		char			buf[1024];
	} req;
	smalluint arg;
	char *name_str = NULL, *link_str = NULL, *type_str = NULL, *dev_str = NULL;

	memset(&req, 0, sizeof(req));

	req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
	req.n.nlmsg_flags = NLM_F_REQUEST;
	req.n.nlmsg_type = rtm;
	req.i.ifi_family = preferred_family;
	if (rtm == RTM_NEWLINK)
		req.n.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;

	while (*argv) {
		arg = index_in_substrings(keywords, *argv);
		if (arg == ARG_link) {
			NEXT_ARG();
			link_str = *argv;
		} else if (arg == ARG_name) {
			NEXT_ARG();
			name_str = *argv;
		} else if (arg == ARG_type) {
			NEXT_ARG();
			type_str = *argv;
		} else {
			if (arg == ARG_dev) {
				if (dev_str)
					duparg(*argv, "dev");
				NEXT_ARG();
			}
			dev_str = *argv;
		}
		argv++;
	}
	xrtnl_open(&rth);
	ll_init_map(&rth);
	if (type_str) {
		struct rtattr *linkinfo = NLMSG_TAIL(&req.n);

		addattr_l(&req.n, sizeof(req), IFLA_LINKINFO, NULL, 0);
		addattr_l(&req.n, sizeof(req), IFLA_INFO_KIND, type_str,
				strlen(type_str));
		linkinfo->rta_len = (void *)NLMSG_TAIL(&req.n) - (void *)linkinfo;
	}
	if (rtm != RTM_NEWLINK) {
		if (!dev_str)
			return 1; /* Need a device to delete */
		req.i.ifi_index = xll_name_to_index(dev_str);
	} else {
		if (!name_str)
			name_str = dev_str;
		if (link_str) {
			int idx = xll_name_to_index(link_str);
			addattr_l(&req.n, sizeof(req), IFLA_LINK, &idx, 4);
		}
	}
	if (name_str) {
		const size_t name_len = strlen(name_str) + 1;
		if (name_len < 2 || name_len > IFNAMSIZ)
			invarg(name_str, "name");
		addattr_l(&req.n, sizeof(req), IFLA_IFNAME, name_str, name_len);
	}
	if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
		return 2;
	return 0;
}

/* Return value becomes exitcode. It's okay to not return at all */
int do_iplink(char **argv)
{
	static const char keywords[] ALIGN1 =
		"add\0""delete\0""set\0""show\0""lst\0""list\0";
	if (*argv) {
		smalluint key = index_in_substrings(keywords, *argv);
		if (key > 5) /* invalid argument */
			bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
		argv++;
		if (key <= 1) /* add/delete */
			return do_change(argv, key ? RTM_DELLINK : RTM_NEWLINK);
		else if (key == 2) /* set */
			return do_set(argv);
	}
	/* show, lst, list */
	return ipaddr_list_link(argv);
}
1	/* vi: set sw=4 ts=4: */
2	/*
3	* iplink.c "ip link".
4	*
5	* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
6	*
7	* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
8	*/
9	#include <net/if.h>
10	#include <net/if_packet.h>
11	#include <netpacket/packet.h>
12	#include <net/ethernet.h>
13
14	#include "ip_common.h" /* #include "libbb.h" is inside */
15	#include "rt_names.h"
16	#include "utils.h"
17
18	#ifndef IFLA_LINKINFO
19	# define IFLA_LINKINFO 18
20	# define IFLA_INFO_KIND 1
21	#endif
22
23	/* taken from linux/sockios.h */
24	#define SIOCSIFNAME 0x8923 /* set interface name */
25
26	/* Exits on error */
27	static int get_ctl_fd(void)
28	{
29	int fd;
30
31	fd = socket(PF_INET, SOCK_DGRAM, 0);
32	if (fd >= 0)
33	return fd;
34	fd = socket(PF_PACKET, SOCK_DGRAM, 0);
35	if (fd >= 0)
36	return fd;
37	return xsocket(PF_INET6, SOCK_DGRAM, 0);
38	}
39
40	/* Exits on error */
41	static void do_chflags(char *dev, uint32_t flags, uint32_t mask)
42	{
43	struct ifreq ifr;
44	int fd;
45
46	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
47	fd = get_ctl_fd();
48	xioctl(fd, SIOCGIFFLAGS, &ifr);
49	if ((ifr.ifr_flags ^ flags) & mask) {
50	ifr.ifr_flags &= ~mask;
51	ifr.ifr_flags \|= mask & flags;
52	xioctl(fd, SIOCSIFFLAGS, &ifr);
53	}
54	close(fd);
55	}
56
57	/* Exits on error */
58	static void do_changename(char dev, char newdev)
59	{
60	struct ifreq ifr;
61	int fd;
62
63	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
64	strncpy_IFNAMSIZ(ifr.ifr_newname, newdev);
65	fd = get_ctl_fd();
66	xioctl(fd, SIOCSIFNAME, &ifr);
67	close(fd);
68	}
69
70	/* Exits on error */
71	static void set_qlen(char *dev, int qlen)
72	{
73	struct ifreq ifr;
74	int s;
75
76	s = get_ctl_fd();
77	memset(&ifr, 0, sizeof(ifr));
78	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
79	ifr.ifr_qlen = qlen;
80	xioctl(s, SIOCSIFTXQLEN, &ifr);
81	close(s);
82	}
83
84	/* Exits on error */
85	static void set_mtu(char *dev, int mtu)
86	{
87	struct ifreq ifr;
88	int s;
89
90	s = get_ctl_fd();
91	memset(&ifr, 0, sizeof(ifr));
92	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
93	ifr.ifr_mtu = mtu;
94	xioctl(s, SIOCSIFMTU, &ifr);
95	close(s);
96	}
97
98	/* Exits on error */
99	static int get_address(char dev, int htype)
100	{
101	struct ifreq ifr;
102	struct sockaddr_ll me;
103	socklen_t alen;
104	int s;
105
106	s = xsocket(PF_PACKET, SOCK_DGRAM, 0);
107
108	memset(&ifr, 0, sizeof(ifr));
109	strncpy_IFNAMSIZ(ifr.ifr_name, dev);
110	xioctl(s, SIOCGIFINDEX, &ifr);
111
112	memset(&me, 0, sizeof(me));
113	me.sll_family = AF_PACKET;
114	me.sll_ifindex = ifr.ifr_ifindex;
115	me.sll_protocol = htons(ETH_P_LOOP);
116	xbind(s, (struct sockaddr*)&me, sizeof(me));
117	alen = sizeof(me);
118	getsockname(s, (struct sockaddr*)&me, &alen);
119	//never happens:
120	//if (getsockname(s, (struct sockaddr*)&me, &alen) == -1)
121	// bb_perror_msg_and_die("getsockname");
122	close(s);
123	*htype = me.sll_hatype;
124	return me.sll_halen;
125	}
126
127	/* Exits on error */
128	static void parse_address(char dev, int hatype, int halen, char lla, struct ifreq *ifr)
129	{
130	int alen;
131
132	memset(ifr, 0, sizeof(*ifr));
133	strncpy_IFNAMSIZ(ifr->ifr_name, dev);
134	ifr->ifr_hwaddr.sa_family = hatype;
135
136	alen = hatype == 1/ARPHRD_ETHER/ ? 14/ETH_HLEN/ : 19/INFINIBAND_HLEN/;
137	alen = ll_addr_a2n((unsigned char *)(ifr->ifr_hwaddr.sa_data), alen, lla);
138	if (alen < 0)
139	exit(EXIT_FAILURE);
140	if (alen != halen) {
141	bb_error_msg_and_die("wrong address (%s) length: expected %d bytes", lla, halen);
142	}
143	}
144
145	/* Exits on error */
146	static void set_address(struct ifreq *ifr, int brd)
147	{
148	int s;
149
150	s = get_ctl_fd();
151	if (brd)
152	xioctl(s, SIOCSIFHWBROADCAST, ifr);
153	else
154	xioctl(s, SIOCSIFHWADDR, ifr);
155	close(s);
156	}
157
158
159	static void die_must_be_on_off(const char *msg) NORETURN;
160	static void die_must_be_on_off(const char *msg)
161	{
162	bb_error_msg_and_die("argument of \"%s\" must be \"on\" or \"off\"", msg);
163	}
164
165	/* Return value becomes exitcode. It's okay to not return at all */
166	static int do_set(char **argv)
167	{
168	char *dev = NULL;
169	uint32_t mask = 0;
170	uint32_t flags = 0;
171	int qlen = -1;
172	int mtu = -1;
173	char *newaddr = NULL;
174	char *newbrd = NULL;
175	struct ifreq ifr0, ifr1;
176	char *newname = NULL;
177	int htype, halen;
178	static const char keywords[] ALIGN1 =
179	"up\0""down\0""name\0""mtu\0""qlen\0""multicast\0"
180	"arp\0""address\0""dev\0";
181	enum { ARG_up = 0, ARG_down, ARG_name, ARG_mtu, ARG_qlen, ARG_multicast,
182	ARG_arp, ARG_addr, ARG_dev };
183	static const char str_on_off[] ALIGN1 = "on\0""off\0";
184	enum { PARM_on = 0, PARM_off };
185	smalluint key;
186
187	while (*argv) {
188	/* substring search ensures that e.g. "addr" and "address"
189	* are both accepted */
190	key = index_in_substrings(keywords, *argv);
191	if (key == ARG_up) {
192	mask \|= IFF_UP;
193	flags \|= IFF_UP;
194	} else if (key == ARG_down) {
195	mask \|= IFF_UP;
196	flags &= ~IFF_UP;
197	} else if (key == ARG_name) {
198	NEXT_ARG();
199	newname = *argv;
200	} else if (key == ARG_mtu) {
201	NEXT_ARG();
202	if (mtu != -1)
203	duparg("mtu", *argv);
204	mtu = get_unsigned(*argv, "mtu");
205	} else if (key == ARG_qlen) {
206	NEXT_ARG();
207	if (qlen != -1)
208	duparg("qlen", *argv);
209	qlen = get_unsigned(*argv, "qlen");
210	} else if (key == ARG_addr) {
211	NEXT_ARG();
212	newaddr = *argv;
213	} else if (key >= ARG_dev) {
214	if (key == ARG_dev) {
215	NEXT_ARG();
216	}
217	if (dev)
218	duparg2("dev", *argv);
219	dev = *argv;
220	} else {
221	int param;
222	NEXT_ARG();
223	param = index_in_strings(str_on_off, *argv);
224	if (key == ARG_multicast) {
225	if (param < 0)
226	die_must_be_on_off("multicast");
227	mask \|= IFF_MULTICAST;
228	if (param == PARM_on)
229	flags \|= IFF_MULTICAST;
230	else
231	flags &= ~IFF_MULTICAST;
232	} else if (key == ARG_arp) {
233	if (param < 0)
234	die_must_be_on_off("arp");
235	mask \|= IFF_NOARP;
236	if (param == PARM_on)
237	flags &= ~IFF_NOARP;
238	else
239	flags \|= IFF_NOARP;
240	}
241	}
242	argv++;
243	}
244
245	if (!dev) {
246	bb_error_msg_and_die(bb_msg_requires_arg, "\"dev\"");
247	}
248
249	if (newaddr \|\| newbrd) {
250	halen = get_address(dev, &htype);
251	if (newaddr) {
252	parse_address(dev, htype, halen, newaddr, &ifr0);
253	set_address(&ifr0, 0);
254	}
255	if (newbrd) {
256	parse_address(dev, htype, halen, newbrd, &ifr1);
257	set_address(&ifr1, 1);
258	}
259	}
260
261	if (newname && strcmp(dev, newname)) {
262	do_changename(dev, newname);
263	dev = newname;
264	}
265	if (qlen != -1) {
266	set_qlen(dev, qlen);
267	}
268	if (mtu != -1) {
269	set_mtu(dev, mtu);
270	}
271	if (mask)
272	do_chflags(dev, flags, mask);
273	return 0;
274	}
275
276	static int ipaddr_list_link(char **argv)
277	{
278	preferred_family = AF_PACKET;
279	return ipaddr_list_or_flush(argv, 0);
280	}
281
282	#ifndef NLMSG_TAIL
283	#define NLMSG_TAIL(nmsg) \
284	((struct rtattr ) (((void ) (nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
285	#endif
286	/* Return value becomes exitcode. It's okay to not return at all */
287	static int do_change(char **argv, const unsigned rtm)
288	{
289	static const char keywords[] ALIGN1 =
290	"link\0""name\0""type\0""dev\0";
291	enum {
292	ARG_link,
293	ARG_name,
294	ARG_type,
295	ARG_dev,
296	};
297	struct rtnl_handle rth;
298	struct {
299	struct nlmsghdr n;
300	struct ifinfomsg i;
301	char buf[1024];
302	} req;
303	smalluint arg;
304	char name_str = NULL, link_str = NULL, type_str = NULL, dev_str = NULL;
305
306	memset(&req, 0, sizeof(req));
307
308	req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
309	req.n.nlmsg_flags = NLM_F_REQUEST;
310	req.n.nlmsg_type = rtm;
311	req.i.ifi_family = preferred_family;
312	if (rtm == RTM_NEWLINK)
313	req.n.nlmsg_flags \|= NLM_F_CREATE\|NLM_F_EXCL;
314
315	while (*argv) {
316	arg = index_in_substrings(keywords, *argv);
317	if (arg == ARG_link) {
318	NEXT_ARG();
319	link_str = *argv;
320	} else if (arg == ARG_name) {
321	NEXT_ARG();
322	name_str = *argv;
323	} else if (arg == ARG_type) {
324	NEXT_ARG();
325	type_str = *argv;
326	} else {
327	if (arg == ARG_dev) {
328	if (dev_str)
329	duparg(*argv, "dev");
330	NEXT_ARG();
331	}
332	dev_str = *argv;
333	}
334	argv++;
335	}
336	xrtnl_open(&rth);
337	ll_init_map(&rth);
338	if (type_str) {
339	struct rtattr *linkinfo = NLMSG_TAIL(&req.n);
340
341	addattr_l(&req.n, sizeof(req), IFLA_LINKINFO, NULL, 0);
342	addattr_l(&req.n, sizeof(req), IFLA_INFO_KIND, type_str,
343	strlen(type_str));
344	linkinfo->rta_len = (void )NLMSG_TAIL(&req.n) - (void )linkinfo;
345	}
346	if (rtm != RTM_NEWLINK) {
347	if (!dev_str)
348	return 1; /* Need a device to delete */
349	req.i.ifi_index = xll_name_to_index(dev_str);
350	} else {
351	if (!name_str)
352	name_str = dev_str;
353	if (link_str) {
354	int idx = xll_name_to_index(link_str);
355	addattr_l(&req.n, sizeof(req), IFLA_LINK, &idx, 4);
356	}
357	}
358	if (name_str) {
359	const size_t name_len = strlen(name_str) + 1;
360	if (name_len < 2 \|\| name_len > IFNAMSIZ)
361	invarg(name_str, "name");
362	addattr_l(&req.n, sizeof(req), IFLA_IFNAME, name_str, name_len);
363	}
364	if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
365	return 2;
366	return 0;
367	}
368
369	/* Return value becomes exitcode. It's okay to not return at all */
370	int do_iplink(char **argv)
371	{
372	static const char keywords[] ALIGN1 =
373	"add\0""delete\0""set\0""show\0""lst\0""list\0";
374	if (*argv) {
375	smalluint key = index_in_substrings(keywords, *argv);
376	if (key > 5) /* invalid argument */
377	bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
378	argv++;
379	if (key <= 1) /* add/delete */
380	return do_change(argv, key ? RTM_DELLINK : RTM_NEWLINK);
381	else if (key == 2) /* set */
382	return do_set(argv);
383	}
384	/* show, lst, list */
385	return ipaddr_list_link(argv);
386	}