Context Navigation

iproute.c@ 3232

Visit:

Last change on this file since 3232 was 3232, checked in by Bruno Cornec, 10 years ago
Update mindi-busybox to 1.21.1
File size: 22.0 KB

Rev	Line
[821]	1	/* vi: set sw=4 ts=4: */
	2	/*
[2725]	3	* Licensed under GPLv2 or later, see file LICENSE in this source tree.
[821]	4	*
[2725]	5	* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
[821]	6	*
	7	* Changes:
	8	*
[2725]	9	* Rani Assaf <rani@magic.metawire.com> 980929: resolve addresses
[821]	10	* Kunihiro Ishiguro <kunihiro@zebra.org> 001102: rtnh_ifindex was not initialized
	11	*/
	12
[2725]	13	#include "ip_common.h" /* #include "libbb.h" is inside */
[821]	14	#include "rt_names.h"
	15	#include "utils.h"
	16
	17	#ifndef RTAX_RTTVAR
	18	#define RTAX_RTTVAR RTAX_HOPS
	19	#endif
	20
	21
[2725]	22	struct filter_t {
[821]	23	int tb;
[2725]	24	smallint flushed;
[821]	25	char *flushb;
	26	int flushp;
	27	int flushe;
	28	struct rtnl_handle *rth;
[2725]	29	//int protocol, protocolmask; - write-only fields?!
	30	//int scope, scopemask; - unused
	31	//int type; - read-only
	32	//int typemask; - unused
	33	//int tos, tosmask; - unused
[3232]	34	int iif;
	35	int oif;
[2725]	36	//int realm, realmmask; - unused
	37	//inet_prefix rprefsrc; - read-only
[821]	38	inet_prefix rvia;
	39	inet_prefix rdst;
	40	inet_prefix mdst;
	41	inet_prefix rsrc;
	42	inet_prefix msrc;
[2725]	43	} FIX_ALIASING;
	44	typedef struct filter_t filter_t;
[821]	45
[2725]	46	#define G_filter ((filter_t)&bb_common_bufsiz1)
[1765]	47
[821]	48	static int flush_update(void)
	49	{
[2725]	50	if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
	51	bb_perror_msg("can't send flush request");
[821]	52	return -1;
	53	}
[2725]	54	G_filter.flushp = 0;
[821]	55	return 0;
	56	}
	57
[1765]	58	static unsigned get_hz(void)
	59	{
	60	static unsigned hz_internal;
	61	FILE *fp;
	62
	63	if (hz_internal)
	64	return hz_internal;
	65
[2725]	66	fp = fopen_for_read("/proc/net/psched");
[1765]	67	if (fp) {
	68	unsigned nom, denom;
	69
	70	if (fscanf(fp, "%08x%08x%08x%08x", &nom, &denom) == 2)
	71	if (nom == 1000000)
	72	hz_internal = denom;
	73	fclose(fp);
	74	}
	75	if (!hz_internal)
	76	hz_internal = sysconf(_SC_CLK_TCK);
	77	return hz_internal;
	78	}
	79
[2725]	80	static int FAST_FUNC print_route(const struct sockaddr_nl *who UNUSED_PARAM,
	81	struct nlmsghdr n, void arg UNUSED_PARAM)
[821]	82	{
	83	struct rtmsg *r = NLMSG_DATA(n);
	84	int len = n->nlmsg_len;
[3232]	85	struct rtattr *tb[RTA_MAX+1];
[821]	86	char abuf[256];
	87	inet_prefix dst;
	88	inet_prefix src;
	89	int host_len = -1;
	90	SPRINT_BUF(b1);
	91
	92	if (n->nlmsg_type != RTM_NEWROUTE && n->nlmsg_type != RTM_DELROUTE) {
	93	fprintf(stderr, "Not a route: %08x %08x %08x\n",
	94	n->nlmsg_len, n->nlmsg_type, n->nlmsg_flags);
	95	return 0;
	96	}
[2725]	97	if (G_filter.flushb && n->nlmsg_type != RTM_NEWROUTE)
[821]	98	return 0;
	99	len -= NLMSG_LENGTH(sizeof(*r));
[1765]	100	if (len < 0)
	101	bb_error_msg_and_die("wrong nlmsg len %d", len);
[821]	102
	103	if (r->rtm_family == AF_INET6)
	104	host_len = 128;
	105	else if (r->rtm_family == AF_INET)
	106	host_len = 32;
	107
	108	if (r->rtm_family == AF_INET6) {
[2725]	109	if (G_filter.tb) {
	110	if (G_filter.tb < 0) {
	111	if (!(r->rtm_flags & RTM_F_CLONED)) {
[821]	112	return 0;
	113	}
	114	} else {
[2725]	115	if (r->rtm_flags & RTM_F_CLONED) {
[821]	116	return 0;
	117	}
[2725]	118	if (G_filter.tb == RT_TABLE_LOCAL) {
[821]	119	if (r->rtm_type != RTN_LOCAL) {
	120	return 0;
	121	}
[2725]	122	} else if (G_filter.tb == RT_TABLE_MAIN) {
[821]	123	if (r->rtm_type == RTN_LOCAL) {
	124	return 0;
	125	}
	126	} else {
	127	return 0;
	128	}
	129	}
	130	}
	131	} else {
[2725]	132	if (G_filter.tb > 0 && G_filter.tb != r->rtm_table) {
[821]	133	return 0;
	134	}
	135	}
[2725]	136	if (G_filter.rdst.family
	137	&& (r->rtm_family != G_filter.rdst.family \|\| G_filter.rdst.bitlen > r->rtm_dst_len)
	138	) {
[821]	139	return 0;
	140	}
[2725]	141	if (G_filter.mdst.family
	142	&& (r->rtm_family != G_filter.mdst.family
	143	\|\| (G_filter.mdst.bitlen >= 0 && G_filter.mdst.bitlen < r->rtm_dst_len)
	144	)
	145	) {
[821]	146	return 0;
	147	}
[2725]	148	if (G_filter.rsrc.family
	149	&& (r->rtm_family != G_filter.rsrc.family \|\| G_filter.rsrc.bitlen > r->rtm_src_len)
	150	) {
[821]	151	return 0;
	152	}
[2725]	153	if (G_filter.msrc.family
	154	&& (r->rtm_family != G_filter.msrc.family
	155	\|\| (G_filter.msrc.bitlen >= 0 && G_filter.msrc.bitlen < r->rtm_src_len)
	156	)
	157	) {
[821]	158	return 0;
	159	}
	160
	161	memset(tb, 0, sizeof(tb));
[3232]	162	memset(&src, 0, sizeof(src));
	163	memset(&dst, 0, sizeof(dst));
[821]	164	parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
	165
[3232]	166	if (tb[RTA_SRC]) {
	167	src.bitlen = r->rtm_src_len;
	168	src.bytelen = (r->rtm_family == AF_INET6 ? 16 : 4);
	169	memcpy(src.data, RTA_DATA(tb[RTA_SRC]), src.bytelen);
	170	}
	171	if (tb[RTA_DST]) {
	172	dst.bitlen = r->rtm_dst_len;
	173	dst.bytelen = (r->rtm_family == AF_INET6 ? 16 : 4);
	174	memcpy(dst.data, RTA_DATA(tb[RTA_DST]), dst.bytelen);
	175	}
	176
[2725]	177	if (G_filter.rdst.family
	178	&& inet_addr_match(&dst, &G_filter.rdst, G_filter.rdst.bitlen)
	179	) {
[821]	180	return 0;
[2725]	181	}
	182	if (G_filter.mdst.family
	183	&& G_filter.mdst.bitlen >= 0
	184	&& inet_addr_match(&dst, &G_filter.mdst, r->rtm_dst_len)
	185	) {
[821]	186	return 0;
[2725]	187	}
	188	if (G_filter.rsrc.family
	189	&& inet_addr_match(&src, &G_filter.rsrc, G_filter.rsrc.bitlen)
	190	) {
[821]	191	return 0;
[2725]	192	}
	193	if (G_filter.msrc.family && G_filter.msrc.bitlen >= 0
	194	&& inet_addr_match(&src, &G_filter.msrc, r->rtm_src_len)
	195	) {
[821]	196	return 0;
[2725]	197	}
[3232]	198	if (G_filter.oif != 0) {
	199	if (!tb[RTA_OIF])
	200	return 0;
	201	if (G_filter.oif != (int)RTA_DATA(tb[RTA_OIF]))
	202	return 0;
[2725]	203	}
[821]	204
[2725]	205	if (G_filter.flushb) {
[821]	206	struct nlmsghdr *fn;
[3232]	207
	208	/* We are creating route flush commands */
	209
	210	if (r->rtm_family == AF_INET6
	211	&& r->rtm_dst_len == 0
	212	&& r->rtm_type == RTN_UNREACHABLE
	213	&& tb[RTA_PRIORITY]
	214	&& (int)RTA_DATA(tb[RTA_PRIORITY]) == -1
	215	) {
	216	return 0;
	217	}
	218
[2725]	219	if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
[821]	220	if (flush_update())
[1765]	221	bb_error_msg_and_die("flush");
[821]	222	}
[3232]	223	fn = (void*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
[821]	224	memcpy(fn, n, n->nlmsg_len);
	225	fn->nlmsg_type = RTM_DELROUTE;
	226	fn->nlmsg_flags = NLM_F_REQUEST;
[2725]	227	fn->nlmsg_seq = ++G_filter.rth->seq;
	228	G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb;
	229	G_filter.flushed = 1;
[821]	230	return 0;
	231	}
	232
[3232]	233	/* We are printing routes */
	234
[821]	235	if (n->nlmsg_type == RTM_DELROUTE) {
[2725]	236	printf("Deleted ");
[821]	237	}
[2725]	238	if (r->rtm_type != RTN_UNICAST /* && !G_filter.type - always 0 */) {
	239	printf("%s ", rtnl_rtntype_n2a(r->rtm_type, b1));
[821]	240	}
	241
	242	if (tb[RTA_DST]) {
	243	if (r->rtm_dst_len != host_len) {
[2725]	244	printf("%s/%u ", rt_addr_n2a(r->rtm_family,
	245	RTA_DATA(tb[RTA_DST]),
	246	abuf, sizeof(abuf)),
	247	r->rtm_dst_len
	248	);
[821]	249	} else {
[2725]	250	printf("%s ", format_host(r->rtm_family,
	251	RTA_PAYLOAD(tb[RTA_DST]),
	252	RTA_DATA(tb[RTA_DST]),
	253	abuf, sizeof(abuf))
	254	);
[821]	255	}
	256	} else if (r->rtm_dst_len) {
[2725]	257	printf("0/%d ", r->rtm_dst_len);
[821]	258	} else {
[2725]	259	printf("default ");
[821]	260	}
	261	if (tb[RTA_SRC]) {
	262	if (r->rtm_src_len != host_len) {
[2725]	263	printf("from %s/%u ", rt_addr_n2a(r->rtm_family,
	264	RTA_DATA(tb[RTA_SRC]),
	265	abuf, sizeof(abuf)),
	266	r->rtm_src_len
	267	);
[821]	268	} else {
[2725]	269	printf("from %s ", format_host(r->rtm_family,
	270	RTA_PAYLOAD(tb[RTA_SRC]),
	271	RTA_DATA(tb[RTA_SRC]),
	272	abuf, sizeof(abuf))
	273	);
[821]	274	}
	275	} else if (r->rtm_src_len) {
[2725]	276	printf("from 0/%u ", r->rtm_src_len);
[821]	277	}
[2725]	278	if (tb[RTA_GATEWAY] && G_filter.rvia.bitlen != host_len) {
	279	printf("via %s ", format_host(r->rtm_family,
	280	RTA_PAYLOAD(tb[RTA_GATEWAY]),
	281	RTA_DATA(tb[RTA_GATEWAY]),
	282	abuf, sizeof(abuf)));
[821]	283	}
[3232]	284	if (tb[RTA_OIF]) {
[2725]	285	printf("dev %s ", ll_index_to_name((int)RTA_DATA(tb[RTA_OIF])));
[821]	286	}
	287
[3232]	288	/* Todo: parse & show "proto kernel", "scope link" here */
	289
[2725]	290	if (tb[RTA_PREFSRC] && /G_filter.rprefsrc.bitlen - always 0/ 0 != host_len) {
[821]	291	/* Do not use format_host(). It is our local addr
	292	and symbolic name will not be useful.
	293	*/
[2725]	294	printf(" src %s ", rt_addr_n2a(r->rtm_family,
	295	RTA_DATA(tb[RTA_PREFSRC]),
	296	abuf, sizeof(abuf)));
[821]	297	}
	298	if (tb[RTA_PRIORITY]) {
[2725]	299	printf(" metric %d ", (uint32_t)RTA_DATA(tb[RTA_PRIORITY]));
[821]	300	}
	301	if (r->rtm_family == AF_INET6) {
	302	struct rta_cacheinfo *ci = NULL;
	303	if (tb[RTA_CACHEINFO]) {
	304	ci = RTA_DATA(tb[RTA_CACHEINFO]);
	305	}
	306	if ((r->rtm_flags & RTM_F_CLONED) \|\| (ci && ci->rta_expires)) {
	307	if (r->rtm_flags & RTM_F_CLONED) {
[2725]	308	printf("%c cache ", _SL_);
[821]	309	}
	310	if (ci->rta_expires) {
[2725]	311	printf(" expires %dsec", ci->rta_expires / get_hz());
[821]	312	}
	313	if (ci->rta_error != 0) {
[2725]	314	printf(" error %d", ci->rta_error);
[821]	315	}
	316	} else if (ci) {
	317	if (ci->rta_error != 0)
[2725]	318	printf(" error %d", ci->rta_error);
[821]	319	}
	320	}
[3232]	321	if (tb[RTA_IIF] && G_filter.iif == 0) {
[2725]	322	printf(" iif %s", ll_index_to_name((int)RTA_DATA(tb[RTA_IIF])));
[821]	323	}
[2725]	324	bb_putchar('\n');
[821]	325	return 0;
	326	}
	327
[1765]	328	/* Return value becomes exitcode. It's okay to not return at all */
[2725]	329	static int iproute_modify(int cmd, unsigned flags, char **argv)
[821]	330	{
[1765]	331	static const char keywords[] ALIGN1 =
[2725]	332	"src\0""via\0""mtu\0""lock\0""protocol\0"IF_FEATURE_IP_RULE("table\0")
	333	"dev\0""oif\0""to\0""metric\0";
[1765]	334	enum {
	335	ARG_src,
	336	ARG_via,
	337	ARG_mtu, PARM_lock,
	338	ARG_protocol,
[2725]	339	IF_FEATURE_IP_RULE(ARG_table,)
[1765]	340	ARG_dev,
	341	ARG_oif,
[2725]	342	ARG_to,
	343	ARG_metric,
[1765]	344	};
	345	enum {
	346	gw_ok = 1 << 0,
	347	dst_ok = 1 << 1,
	348	proto_ok = 1 << 2,
	349	type_ok = 1 << 3
	350	};
[821]	351	struct rtnl_handle rth;
	352	struct {
[2725]	353	struct nlmsghdr n;
	354	struct rtmsg r;
	355	char buf[1024];
[821]	356	} req;
[1765]	357	char mxbuf[256];
[821]	358	struct rtattr * mxrta = (void*)mxbuf;
	359	unsigned mxlock = 0;
[1765]	360	char *d = NULL;
	361	smalluint ok = 0;
	362	int arg;
[821]	363
	364	memset(&req, 0, sizeof(req));
	365
	366	req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
[2725]	367	req.n.nlmsg_flags = NLM_F_REQUEST \| flags;
[821]	368	req.n.nlmsg_type = cmd;
	369	req.r.rtm_family = preferred_family;
[2725]	370	if (RT_TABLE_MAIN) /* if it is zero, memset already did it */
	371	req.r.rtm_table = RT_TABLE_MAIN;
	372	if (RT_SCOPE_NOWHERE)
	373	req.r.rtm_scope = RT_SCOPE_NOWHERE;
[821]	374
	375	if (cmd != RTM_DELROUTE) {
	376	req.r.rtm_protocol = RTPROT_BOOT;
	377	req.r.rtm_scope = RT_SCOPE_UNIVERSE;
	378	req.r.rtm_type = RTN_UNICAST;
	379	}
	380
	381	mxrta->rta_type = RTA_METRICS;
	382	mxrta->rta_len = RTA_LENGTH(0);
	383
[2725]	384	while (*argv) {
[1765]	385	arg = index_in_substrings(keywords, *argv);
	386	if (arg == ARG_src) {
[821]	387	inet_prefix addr;
	388	NEXT_ARG();
	389	get_addr(&addr, *argv, req.r.rtm_family);
[1765]	390	if (req.r.rtm_family == AF_UNSPEC)
[821]	391	req.r.rtm_family = addr.family;
	392	addattr_l(&req.n, sizeof(req), RTA_PREFSRC, &addr.data, addr.bytelen);
[1765]	393	} else if (arg == ARG_via) {
[821]	394	inet_prefix addr;
[1765]	395	ok \|= gw_ok;
[821]	396	NEXT_ARG();
	397	get_addr(&addr, *argv, req.r.rtm_family);
	398	if (req.r.rtm_family == AF_UNSPEC) {
	399	req.r.rtm_family = addr.family;
	400	}
	401	addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &addr.data, addr.bytelen);
[1765]	402	} else if (arg == ARG_mtu) {
[821]	403	unsigned mtu;
	404	NEXT_ARG();
[1765]	405	if (index_in_strings(keywords, *argv) == PARM_lock) {
[2725]	406	mxlock \|= (1 << RTAX_MTU);
[821]	407	NEXT_ARG();
	408	}
[2725]	409	mtu = get_unsigned(*argv, "mtu");
[821]	410	rta_addattr32(mxrta, sizeof(mxbuf), RTAX_MTU, mtu);
[1765]	411	} else if (arg == ARG_protocol) {
[821]	412	uint32_t prot;
	413	NEXT_ARG();
	414	if (rtnl_rtprot_a2n(&prot, *argv))
	415	invarg(*argv, "protocol");
	416	req.r.rtm_protocol = prot;
[1765]	417	ok \|= proto_ok;
	418	#if ENABLE_FEATURE_IP_RULE
	419	} else if (arg == ARG_table) {
	420	uint32_t tid;
[821]	421	NEXT_ARG();
[1765]	422	if (rtnl_rttable_a2n(&tid, *argv))
	423	invarg(*argv, "table");
	424	req.r.rtm_table = tid;
	425	#endif
	426	} else if (arg == ARG_dev \|\| arg == ARG_oif) {
	427	NEXT_ARG();
[821]	428	d = *argv;
[2725]	429	} else if (arg == ARG_metric) {
	430	uint32_t metric;
	431	NEXT_ARG();
	432	metric = get_u32(*argv, "metric");
	433	addattr32(&req.n, sizeof(req), RTA_PRIORITY, metric);
[821]	434	} else {
	435	int type;
	436	inet_prefix dst;
	437
[1765]	438	if (arg == ARG_to) {
[821]	439	NEXT_ARG();
	440	}
[1765]	441	if ((argv < '0' \|\| argv > '9')
[3232]	442	&& rtnl_rtntype_a2n(&type, *argv) == 0
	443	) {
[821]	444	NEXT_ARG();
	445	req.r.rtm_type = type;
[1765]	446	ok \|= type_ok;
[821]	447	}
	448
[1765]	449	if (ok & dst_ok) {
[821]	450	duparg2("to", *argv);
	451	}
	452	get_prefix(&dst, *argv, req.r.rtm_family);
	453	if (req.r.rtm_family == AF_UNSPEC) {
	454	req.r.rtm_family = dst.family;
	455	}
	456	req.r.rtm_dst_len = dst.bitlen;
[1765]	457	ok \|= dst_ok;
[821]	458	if (dst.bytelen) {
	459	addattr_l(&req.n, sizeof(req), RTA_DST, &dst.data, dst.bytelen);
	460	}
	461	}
[2725]	462	argv++;
[821]	463	}
	464
[1765]	465	xrtnl_open(&rth);
[821]	466
	467	if (d) {
	468	int idx;
	469
	470	ll_init_map(&rth);
	471
	472	if (d) {
[1765]	473	idx = xll_name_to_index(d);
[821]	474	addattr32(&req.n, sizeof(req), RTA_OIF, idx);
	475	}
	476	}
	477
	478	if (mxrta->rta_len > RTA_LENGTH(0)) {
	479	if (mxlock) {
	480	rta_addattr32(mxrta, sizeof(mxbuf), RTAX_LOCK, mxlock);
	481	}
	482	addattr_l(&req.n, sizeof(req), RTA_METRICS, RTA_DATA(mxrta), RTA_PAYLOAD(mxrta));
	483	}
	484
[1765]	485	if (req.r.rtm_type == RTN_LOCAL \|\| req.r.rtm_type == RTN_NAT)
	486	req.r.rtm_scope = RT_SCOPE_HOST;
[2725]	487	else
	488	if (req.r.rtm_type == RTN_BROADCAST
	489	\|\| req.r.rtm_type == RTN_MULTICAST
	490	\|\| req.r.rtm_type == RTN_ANYCAST
	491	) {
[1765]	492	req.r.rtm_scope = RT_SCOPE_LINK;
[2725]	493	}
[1765]	494	else if (req.r.rtm_type == RTN_UNICAST \|\| req.r.rtm_type == RTN_UNSPEC) {
	495	if (cmd == RTM_DELROUTE)
	496	req.r.rtm_scope = RT_SCOPE_NOWHERE;
	497	else if (!(ok & gw_ok))
	498	req.r.rtm_scope = RT_SCOPE_LINK;
	499	}
	500
[821]	501	if (req.r.rtm_family == AF_UNSPEC) {
	502	req.r.rtm_family = AF_INET;
	503	}
	504
	505	if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0) {
[1765]	506	return 2;
[821]	507	}
	508
	509	return 0;
	510	}
	511
	512	static int rtnl_rtcache_request(struct rtnl_handle *rth, int family)
	513	{
	514	struct {
	515	struct nlmsghdr nlh;
	516	struct rtmsg rtm;
	517	} req;
	518	struct sockaddr_nl nladdr;
	519
	520	memset(&nladdr, 0, sizeof(nladdr));
	521	memset(&req, 0, sizeof(req));
	522	nladdr.nl_family = AF_NETLINK;
	523
	524	req.nlh.nlmsg_len = sizeof(req);
[2725]	525	if (RTM_GETROUTE)
	526	req.nlh.nlmsg_type = RTM_GETROUTE;
	527	if (NLM_F_ROOT \| NLM_F_REQUEST)
	528	req.nlh.nlmsg_flags = NLM_F_ROOT \| NLM_F_REQUEST;
	529	/req.nlh.nlmsg_pid = 0; - memset did it already /
[821]	530	req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
	531	req.rtm.rtm_family = family;
[2725]	532	if (RTM_F_CLONED)
	533	req.rtm.rtm_flags = RTM_F_CLONED;
[821]	534
[1765]	535	return xsendto(rth->fd, (void)&req, sizeof(req), (struct sockaddr)&nladdr, sizeof(nladdr));
[821]	536	}
	537
[1765]	538	static void iproute_flush_cache(void)
[821]	539	{
[1765]	540	static const char fn[] ALIGN1 = "/proc/sys/net/ipv4/route/flush";
	541	int flush_fd = open_or_warn(fn, O_WRONLY);
[821]	542
	543	if (flush_fd < 0) {
[1765]	544	return;
[821]	545	}
	546
[1765]	547	if (write(flush_fd, "-1", 2) < 2) {
[2725]	548	bb_perror_msg("can't flush routing cache");
[1765]	549	return;
[821]	550	}
	551	close(flush_fd);
	552	}
	553
	554	static void iproute_reset_filter(void)
	555	{
[2725]	556	memset(&G_filter, 0, sizeof(G_filter));
	557	G_filter.mdst.bitlen = -1;
	558	G_filter.msrc.bitlen = -1;
[821]	559	}
	560
[1765]	561	/* Return value becomes exitcode. It's okay to not return at all */
[2725]	562	static int iproute_list_or_flush(char **argv, int flush)
[821]	563	{
	564	int do_ipv6 = preferred_family;
	565	struct rtnl_handle rth;
	566	char *id = NULL;
	567	char *od = NULL;
[1765]	568	static const char keywords[] ALIGN1 =
[2725]	569	/* "ip route list/flush" parameters: */
	570	"protocol\0" "dev\0" "oif\0" "iif\0"
	571	"via\0" "table\0" "cache\0"
	572	"from\0" "to\0"
	573	/* and possible further keywords */
	574	"all\0"
	575	"root\0"
	576	"match\0"
	577	"exact\0"
	578	"main\0"
	579	;
[1765]	580	enum {
[2725]	581	KW_proto, KW_dev, KW_oif, KW_iif,
	582	KW_via, KW_table, KW_cache,
	583	KW_from, KW_to,
	584	/* */
	585	KW_all,
	586	KW_root,
	587	KW_match,
	588	KW_exact,
	589	KW_main,
[1765]	590	};
	591	int arg, parm;
[2725]	592
[821]	593	iproute_reset_filter();
[2725]	594	G_filter.tb = RT_TABLE_MAIN;
[821]	595
[2725]	596	if (flush && !*argv)
[1765]	597	bb_error_msg_and_die(bb_msg_requires_arg, "\"ip route flush\"");
[821]	598
[2725]	599	while (*argv) {
[1765]	600	arg = index_in_substrings(keywords, *argv);
[2725]	601	if (arg == KW_proto) {
[821]	602	uint32_t prot = 0;
	603	NEXT_ARG();
[2725]	604	//G_filter.protocolmask = -1;
[821]	605	if (rtnl_rtprot_a2n(&prot, *argv)) {
[2725]	606	if (index_in_strings(keywords, *argv) != KW_all)
[821]	607	invarg(*argv, "protocol");
	608	prot = 0;
[2725]	609	//G_filter.protocolmask = 0;
[821]	610	}
[2725]	611	//G_filter.protocol = prot;
	612	} else if (arg == KW_dev \|\| arg == KW_oif) {
[821]	613	NEXT_ARG();
	614	od = *argv;
[2725]	615	} else if (arg == KW_iif) {
[821]	616	NEXT_ARG();
	617	id = *argv;
[2725]	618	} else if (arg == KW_via) {
[821]	619	NEXT_ARG();
[2725]	620	get_prefix(&G_filter.rvia, *argv, do_ipv6);
	621	} else if (arg == KW_table) { /* table all/cache/main */
[1765]	622	NEXT_ARG();
	623	parm = index_in_substrings(keywords, *argv);
[2725]	624	if (parm == KW_cache)
	625	G_filter.tb = -1;
	626	else if (parm == KW_all)
	627	G_filter.tb = 0;
	628	else if (parm != KW_main) {
	629	#if ENABLE_FEATURE_IP_RULE
	630	uint32_t tid;
	631	if (rtnl_rttable_a2n(&tid, *argv))
	632	invarg(*argv, "table");
	633	G_filter.tb = tid;
	634	#else
[1765]	635	invarg(*argv, "table");
[2725]	636	#endif
	637	}
	638	} else if (arg == KW_cache) {
	639	/* The command 'ip route flush cache' is used by OpenSWAN.
	640	* Assuming it's a synonym for 'ip route flush table cache' */
	641	G_filter.tb = -1;
	642	} else if (arg == KW_from) {
[1765]	643	NEXT_ARG();
	644	parm = index_in_substrings(keywords, *argv);
[2725]	645	if (parm == KW_root) {
[821]	646	NEXT_ARG();
[2725]	647	get_prefix(&G_filter.rsrc, *argv, do_ipv6);
	648	} else if (parm == KW_match) {
[821]	649	NEXT_ARG();
[2725]	650	get_prefix(&G_filter.msrc, *argv, do_ipv6);
[821]	651	} else {
[2725]	652	if (parm == KW_exact)
[821]	653	NEXT_ARG();
[2725]	654	get_prefix(&G_filter.msrc, *argv, do_ipv6);
	655	G_filter.rsrc = G_filter.msrc;
[821]	656	}
[2725]	657	} else { /* "to" is the default parameter */
	658	if (arg == KW_to) {
[821]	659	NEXT_ARG();
[1765]	660	arg = index_in_substrings(keywords, *argv);
[821]	661	}
[2725]	662	/* parm = arg; - would be more plausible, but we reuse 'arg' here */
	663	if (arg == KW_root) {
[821]	664	NEXT_ARG();
[2725]	665	get_prefix(&G_filter.rdst, *argv, do_ipv6);
	666	} else if (arg == KW_match) {
[821]	667	NEXT_ARG();
[2725]	668	get_prefix(&G_filter.mdst, *argv, do_ipv6);
	669	} else { /* "to exact" is the default */
	670	if (arg == KW_exact)
[821]	671	NEXT_ARG();
[2725]	672	get_prefix(&G_filter.mdst, *argv, do_ipv6);
	673	G_filter.rdst = G_filter.mdst;
[821]	674	}
	675	}
[1765]	676	argv++;
[821]	677	}
	678
[2725]	679	if (do_ipv6 == AF_UNSPEC && G_filter.tb) {
[821]	680	do_ipv6 = AF_INET;
	681	}
	682
[1765]	683	xrtnl_open(&rth);
[821]	684	ll_init_map(&rth);
	685
	686	if (id \|\| od) {
	687	int idx;
	688
	689	if (id) {
[1765]	690	idx = xll_name_to_index(id);
[2725]	691	G_filter.iif = idx;
[821]	692	}
	693	if (od) {
[1765]	694	idx = xll_name_to_index(od);
[2725]	695	G_filter.oif = idx;
[821]	696	}
	697	}
	698
	699	if (flush) {
	700	char flushb[4096-512];
	701
[2725]	702	if (G_filter.tb == -1) { /* "flush table cache" */
[821]	703	if (do_ipv6 != AF_INET6)
	704	iproute_flush_cache();
	705	if (do_ipv6 == AF_INET)
	706	return 0;
	707	}
	708
[2725]	709	G_filter.flushb = flushb;
	710	G_filter.flushp = 0;
	711	G_filter.flushe = sizeof(flushb);
	712	G_filter.rth = &rth;
[821]	713
	714	for (;;) {
[1765]	715	xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
[2725]	716	G_filter.flushed = 0;
	717	xrtnl_dump_filter(&rth, print_route, NULL);
	718	if (G_filter.flushed == 0)
[821]	719	return 0;
[1765]	720	if (flush_update())
	721	return 1;
[821]	722	}
	723	}
	724
[2725]	725	if (G_filter.tb != -1) {
[1765]	726	xrtnl_wilddump_request(&rth, do_ipv6, RTM_GETROUTE);
	727	} else if (rtnl_rtcache_request(&rth, do_ipv6) < 0) {
[2725]	728	bb_perror_msg_and_die("can't send dump request");
[821]	729	}
[2725]	730	xrtnl_dump_filter(&rth, print_route, NULL);
[821]	731
[1765]	732	return 0;
[821]	733	}
	734
	735
[1765]	736	/* Return value becomes exitcode. It's okay to not return at all */
[2725]	737	static int iproute_get(char **argv)
[821]	738	{
	739	struct rtnl_handle rth;
	740	struct {
[1765]	741	struct nlmsghdr n;
	742	struct rtmsg r;
	743	char buf[1024];
[821]	744	} req;
[1765]	745	char *idev = NULL;
	746	char *odev = NULL;
	747	bool connected = 0;
	748	bool from_ok = 0;
	749	static const char options[] ALIGN1 =
	750	"from\0""iif\0""oif\0""dev\0""notify\0""connected\0""to\0";
[821]	751
	752	memset(&req, 0, sizeof(req));
	753
	754	iproute_reset_filter();
	755
	756	req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
[2725]	757	if (NLM_F_REQUEST)
	758	req.n.nlmsg_flags = NLM_F_REQUEST;
	759	if (RTM_GETROUTE)
	760	req.n.nlmsg_type = RTM_GETROUTE;
[821]	761	req.r.rtm_family = preferred_family;
[2725]	762	/req.r.rtm_table = 0; - memset did this already /
	763	/req.r.rtm_protocol = 0;/
	764	/req.r.rtm_scope = 0;/
	765	/req.r.rtm_type = 0;/
	766	/req.r.rtm_src_len = 0;/
	767	/req.r.rtm_dst_len = 0;/
	768	/req.r.rtm_tos = 0;/
[821]	769
[2725]	770	while (*argv) {
[1765]	771	switch (index_in_strings(options, *argv)) {
[821]	772	case 0: /* from */
	773	{
	774	inet_prefix addr;
	775	NEXT_ARG();
	776	from_ok = 1;
	777	get_prefix(&addr, *argv, req.r.rtm_family);
	778	if (req.r.rtm_family == AF_UNSPEC) {
	779	req.r.rtm_family = addr.family;
	780	}
	781	if (addr.bytelen) {
	782	addattr_l(&req.n, sizeof(req), RTA_SRC, &addr.data, addr.bytelen);
	783	}
	784	req.r.rtm_src_len = addr.bitlen;
	785	break;
	786	}
	787	case 1: /* iif */
	788	NEXT_ARG();
	789	idev = *argv;
	790	break;
	791	case 2: /* oif */
	792	case 3: /* dev */
	793	NEXT_ARG();
	794	odev = *argv;
	795	break;
	796	case 4: /* notify */
	797	req.r.rtm_flags \|= RTM_F_NOTIFY;
	798	break;
	799	case 5: /* connected */
	800	connected = 1;
	801	break;
	802	case 6: /* to */
	803	NEXT_ARG();
	804	default:
	805	{
	806	inet_prefix addr;
	807	get_prefix(&addr, *argv, req.r.rtm_family);
	808	if (req.r.rtm_family == AF_UNSPEC) {
	809	req.r.rtm_family = addr.family;
	810	}
	811	if (addr.bytelen) {
	812	addattr_l(&req.n, sizeof(req), RTA_DST, &addr.data, addr.bytelen);
	813	}
	814	req.r.rtm_dst_len = addr.bitlen;
	815	}
	816	}
[2725]	817	argv++;
[821]	818	}
	819
	820	if (req.r.rtm_dst_len == 0) {
	821	bb_error_msg_and_die("need at least destination address");
	822	}
	823
[1765]	824	xrtnl_open(&rth);
[821]	825
	826	ll_init_map(&rth);
	827
	828	if (idev \|\| odev) {
	829	int idx;
	830
	831	if (idev) {
[1765]	832	idx = xll_name_to_index(idev);
[821]	833	addattr32(&req.n, sizeof(req), RTA_IIF, idx);
	834	}
	835	if (odev) {
[1765]	836	idx = xll_name_to_index(odev);
[821]	837	addattr32(&req.n, sizeof(req), RTA_OIF, idx);
	838	}
	839	}
	840
	841	if (req.r.rtm_family == AF_UNSPEC) {
	842	req.r.rtm_family = AF_INET;
	843	}
	844
	845	if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
[1765]	846	return 2;
[821]	847	}
	848
	849	if (connected && !from_ok) {
	850	struct rtmsg *r = NLMSG_DATA(&req.n);
	851	int len = req.n.nlmsg_len;
	852	struct rtattr * tb[RTA_MAX+1];
	853
[2725]	854	print_route(NULL, &req.n, NULL);
[821]	855
	856	if (req.n.nlmsg_type != RTM_NEWROUTE) {
[1765]	857	bb_error_msg_and_die("not a route?");
[821]	858	}
	859	len -= NLMSG_LENGTH(sizeof(*r));
	860	if (len < 0) {
[1765]	861	bb_error_msg_and_die("wrong len %d", len);
[821]	862	}
	863
	864	memset(tb, 0, sizeof(tb));
	865	parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
	866
	867	if (tb[RTA_PREFSRC]) {
	868	tb[RTA_PREFSRC]->rta_type = RTA_SRC;
	869	r->rtm_src_len = 8*RTA_PAYLOAD(tb[RTA_PREFSRC]);
	870	} else if (!tb[RTA_SRC]) {
[2725]	871	bb_error_msg_and_die("can't connect the route");
[821]	872	}
	873	if (!odev && tb[RTA_OIF]) {
	874	tb[RTA_OIF]->rta_type = 0;
	875	}
	876	if (tb[RTA_GATEWAY]) {
	877	tb[RTA_GATEWAY]->rta_type = 0;
	878	}
	879	if (!idev && tb[RTA_IIF]) {
	880	tb[RTA_IIF]->rta_type = 0;
	881	}
	882	req.n.nlmsg_flags = NLM_F_REQUEST;
	883	req.n.nlmsg_type = RTM_GETROUTE;
	884
	885	if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0) {
[1765]	886	return 2;
[821]	887	}
	888	}
[2725]	889	print_route(NULL, &req.n, NULL);
[1765]	890	return 0;
[821]	891	}
	892
[1765]	893	/* Return value becomes exitcode. It's okay to not return at all */
[2725]	894	int FAST_FUNC do_iproute(char **argv)
[821]	895	{
[1765]	896	static const char ip_route_commands[] ALIGN1 =
	897	/0-3/ "add\0""append\0""change\0""chg\0"
	898	/4-7/ "delete\0""get\0""list\0""show\0"
	899	/8../ "prepend\0""replace\0""test\0""flush\0";
[2725]	900	int command_num;
[1765]	901	unsigned flags = 0;
[821]	902	int cmd = RTM_NEWROUTE;
	903
[2725]	904	if (!*argv)
	905	return iproute_list_or_flush(argv, 0);
	906
[1765]	907	/* "Standard" 'ip r a' treats 'a' as 'add', not 'append' */
	908	/* It probably means that it is using "first match" rule */
[2725]	909	command_num = index_in_substrings(ip_route_commands, *argv);
	910
[1765]	911	switch (command_num) {
	912	case 0: /* add */
[821]	913	flags = NLM_F_CREATE\|NLM_F_EXCL;
	914	break;
	915	case 1: /* append */
	916	flags = NLM_F_CREATE\|NLM_F_APPEND;
	917	break;
	918	case 2: /* change */
	919	case 3: /* chg */
	920	flags = NLM_F_REPLACE;
	921	break;
	922	case 4: /* delete */
	923	cmd = RTM_DELROUTE;
	924	break;
[1765]	925	case 5: /* get */
[2725]	926	return iproute_get(argv+1);
[1765]	927	case 6: /* list */
	928	case 7: /* show */
[2725]	929	return iproute_list_or_flush(argv+1, 0);
[1765]	930	case 8: /* prepend */
[821]	931	flags = NLM_F_CREATE;
[2725]	932	break;
[1765]	933	case 9: /* replace */
[821]	934	flags = NLM_F_CREATE\|NLM_F_REPLACE;
[2725]	935	break;
[1765]	936	case 10: /* test */
[821]	937	flags = NLM_F_EXCL;
[2725]	938	break;
[1765]	939	case 11: /* flush */
[2725]	940	return iproute_list_or_flush(argv+1, 1);
[821]	941	default:
[1765]	942	bb_error_msg_and_die("unknown command %s", *argv);
[821]	943	}
	944
[2725]	945	return iproute_modify(cmd, flags, argv+1);
[821]	946	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: MondoRescue/branches/3.2/mindi-busybox/networking/libiproute/iproute.c@ 3232

Download in other formats: