- add WIP stub for tc.

Printing worked at some point. Modify/Delete needs some refacturing.

include/applets.h

@@ -355,6 +355,7 @@ USE_TAC(APPLET_NOEXEC(tac, tac, _BB_DIR_USR_BIN, _BB_SUID_NEVER, tac))
 USE_TAIL(APPLET(tail, _BB_DIR_USR_BIN, _BB_SUID_NEVER))
 USE_TAR(APPLET(tar, _BB_DIR_BIN, _BB_SUID_NEVER))
 USE_TASKSET(APPLET(taskset, _BB_DIR_USR_BIN, _BB_SUID_NEVER))
+USE_TC(APPLET(tc, _BB_DIR_SBIN, _BB_SUID_NEVER))
 USE_TCPSVD(APPLET_ODDNAME(tcpsvd, tcpudpsvd, _BB_DIR_USR_BIN, _BB_SUID_NEVER, tcpsvd))
 USE_TEE(APPLET(tee, _BB_DIR_USR_BIN, _BB_SUID_NEVER))
 USE_TELNET(APPLET(telnet, _BB_DIR_USR_BIN, _BB_SUID_NEVER))

include/usage.h

@@ -4111,6 +4111,26 @@
        "$ echo $?\n" \
        "1\n"
 
+#define tc_trivial_usage \
+	/*"[OPTIONS] "*/"OBJECT CMD [dev STRING]"
+#define tc_full_usage "\n\n" \
+	"OBJECT: {qdisc|class|filter}\n" \
+	"CMD: {add|del|change|replace|show}\n" \
+	"\n" \
+	"qdisc [ handle QHANDLE ] [ root |"USE_FEATURE_TC_INGRESS(" ingress |")" parent CLASSID ]\n" \
+	/* "\t[ estimator INTERVAL TIME_CONSTANT ]\n" */ \
+	"\t[ [ QDISC_KIND ] [ help | OPTIONS ] ]\n" \
+	"\tQDISC_KIND := { [p|b]fifo | tbf | prio | cbq | red | etc. }\n" \
+	"qdisc show [ dev STRING ]"USE_FEATURE_TC_INGRESS(" [ingress]")"\n" \
+	"class [ classid CLASSID ] [ root | parent CLASSID ]\n" \
+	"\t[ [ QDISC_KIND ] [ help | OPTIONS ] ]\n" \
+	"class show [ dev STRING ] [ root | parent CLASSID ]\n" \
+	"filter [ pref PRIO ] [ protocol PROTO ]\n" \
+	/* "\t[ estimator INTERVAL TIME_CONSTANT ]\n" */ \
+	"\t[ root | classid CLASSID ] [ handle FILTERID ]\n" \
+	"\t[ [ FILTER_TYPE ] [ help | OPTIONS ] ]\n" \
+	"filter show [ dev STRING ] [ root | parent CLASSID ]"
+
 #define tcpsvd_trivial_usage \
        "[-hEv] [-c n] [-C n:msg] [-b n] [-u user] [-l name] ip port prog..."
 /* with not-implemented options: */

networking/Config.in

@@ -700,6 +700,16 @@ config SLATTACH
 	  slattach is a small utility to attach network interfaces to serial
 	  lines.
 
+#config TC
+#	bool "tc"
+#	default n
+#	help
+#	  show / manipulate traffic control settings
+#
+#config FEATURE_TC_INGRESS
+#	def_bool n
+#	depends on TC
+
 config TELNET
 	bool "telnet"
 	default n

networking/Kbuild

@@ -32,6 +32,7 @@ lib-$(CONFIG_PSCAN)        += pscan.o
 lib-$(CONFIG_ROUTE)        += route.o
 lib-$(CONFIG_SENDMAIL)     += sendmail.o
 lib-$(CONFIG_SLATTACH)     += slattach.o
+lib-$(CONFIG_TC)           += tc.o
 lib-$(CONFIG_TELNET)       += telnet.o
 lib-$(CONFIG_TELNETD)      += telnetd.o
 lib-$(CONFIG_TFTP)         += tftp.o

networking/libiproute/ll_proto.c

@@ -20,7 +20,7 @@
 #include <linux/if_ether.h>
 #endif
 
-#ifdef UNUSED
+#warning de-bloat
 /* Before re-enabling this, please (1) conditionalize exotic protocols
  * on CONFIG_something, and (2) decouple strings and numbers
  * (use llproto_ids[] = n,n,n..; and llproto_names[] = "loop\0" "pup\0" ...;)
@@ -123,4 +123,3 @@ int ll_proto_a2n(unsigned short *id, char *buf)
 	return 0;
 }
 
-#endif /* UNUSED */

networking/libiproute/rt_names.h

@@ -24,10 +24,9 @@ extern const char* ll_addr_n2a(unsigned char *addr, int alen, int type,
 				char *buf, int blen);
 extern int ll_addr_a2n(unsigned char *lladdr, int len, char *arg);
 
-#ifdef UNUSED
+
 extern const char* ll_proto_n2a(unsigned short id, char *buf, int len);
 extern int ll_proto_a2n(unsigned short *id, char *buf);
-#endif
 
 #if __GNUC_PREREQ(4,1)
 # pragma GCC visibility pop

networking/tc.c

@@ -0,0 +1,545 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * tc.c		"tc" utility frontend.
+ *
+ * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
+ *
+ * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
+ *
+ * Bernhard Fischer adjusted for busybox
+ */
+
+#include "libbb.h"
+
+#include "libiproute/utils.h"
+#include "libiproute/ip_common.h"
+#include "libiproute/rt_names.h"
+#include <linux/pkt_sched.h> /* for the TC_H_* macros */
+
+#define parse_rtattr_nested(tb, max, rta) \
+	(parse_rtattr((tb), (max), RTA_DATA(rta), RTA_PAYLOAD(rta)))
+
+/* nullifies tb on error */
+#define __parse_rtattr_nested_compat(tb, max, rta, len) \
+	({if ((RTA_PAYLOAD(rta) >= len) && \
+		 (RTA_PAYLOAD(rta) >= RTA_ALIGN(len) + sizeof(struct rtattr))) { \
+			rta = RTA_DATA(rta) + RTA_ALIGN(len); \
+			parse_rtattr_nested(tb, max, rta); \
+	  } else \
+			memset(tb, 0, sizeof(struct rtattr *) * (max + 1)); \
+	})
+
+#define parse_rtattr_nested_compat(tb, max, rta, data, len) \
+	({data = RTA_PAYLOAD(rta) >= len ? RTA_DATA(rta) : NULL; \
+	__parse_rtattr_nested_compat(tb, max, rta, len); })
+
+#define show_details (0) /* not implemented. Does anyone need it? */
+#define use_iec (0) /* not currently documented in the upstream manpage */
+
+
+struct globals {
+	int filter_ifindex;
+	__u32 filter_qdisc;
+	__u32 filter_parent;
+	__u32 filter_prio;
+	__u32 filter_proto;
+};
+
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define filter_ifindex (G.filter_ifindex)
+#define filter_qdisc (G.filter_qdisc)
+#define filter_parent (G.filter_parent)
+#define filter_prio (G.filter_prio)
+#define filter_proto (G.filter_proto)
+
+void BUG_tc_globals_too_big(void);
+#define INIT_G() do { \
+	if (sizeof(G) > COMMON_BUFSIZE) \
+		BUG_tc_globals_too_big(); \
+} while (0)
+
+/* Allocates a buffer containing the name of a class id.
+ * The caller must free the returned memory.  */
+static char* print_tc_classid(uint32_t cid)
+{
+#if 0 /* IMPOSSIBLE */
+	if (cid == TC_H_ROOT)
+		return xasprintf("root");
+	else
+#endif
+	if (cid == TC_H_UNSPEC)
+		return xasprintf("none");
+	else if (TC_H_MAJ(cid) == 0)
+		return xasprintf(":%x", TC_H_MIN(cid));
+	else if (TC_H_MIN(cid) == 0)
+		return xasprintf("%x:", TC_H_MAJ(cid)>>16);
+	else
+		return xasprintf("%x:%x", TC_H_MAJ(cid)>>16, TC_H_MIN(cid));
+}
+
+/* Get a qdisc handle.  Return 0 on success, !0 otherwise.  */
+static int get_qdisc_handle(__u32 *h, const char *str) {
+	__u32 maj;
+	char *p;
+
+	maj = TC_H_UNSPEC;
+	if (!strcmp(str, "none"))
+		goto ok;
+	maj = strtoul(str, &p, 16);
+	if (p == str)
+		return 1;
+	maj <<= 16;
+	if (*p != ':' && *p!=0)
+		return 1;
+ ok:
+	*h = maj;
+	return 0;
+}
+
+/* Get class ID.  Return 0 on success, !0 otherwise.  */
+static int get_tc_classid(__u32 *h, const char *str) {
+	__u32 maj, min;
+	char *p;
+
+	maj = TC_H_ROOT;
+	if (!strcmp(str, "root"))
+		goto ok;
+	maj = TC_H_UNSPEC;
+	if (!strcmp(str, "none"))
+		goto ok;
+	maj = strtoul(str, &p, 16);
+	if (p == str) {
+		if (*p != ':')
+			return 1;
+		maj = 0;
+	}
+	if (*p == ':') {
+		if (maj >= (1<<16))
+			return 1;
+		maj <<= 16;
+		str = p + 1;
+		min = strtoul(str, &p, 16);
+		if (*p != 0 || min >= (1<<16))
+			return 1;
+		maj |= min;
+	} else if (*p != 0)
+		return 1;
+ ok:
+	*h = maj;
+	return 0;
+}
+
+static void print_rate(char *buf, int len, uint32_t rate)
+{
+	double tmp = (double)rate*8;
+
+	if (use_iec) {
+		if (tmp >= 1000.0*1024.0*1024.0)
+			snprintf(buf, len, "%.0fMibit", tmp/1024.0*1024.0);
+		else if (tmp >= 1000.0*1024)
+			snprintf(buf, len, "%.0fKibit", tmp/1024);
+		else
+			snprintf(buf, len, "%.0fbit", tmp);
+	} else {
+		if (tmp >= 1000.0*1000000.0)
+			snprintf(buf, len, "%.0fMbit", tmp/1000000.0);
+		else if (tmp >= 1000.0 * 1000.0)
+			snprintf(buf, len, "%.0fKbit", tmp/1000.0);
+		else
+			snprintf(buf, len, "%.0fbit",  tmp);
+	}
+}
+
+/* This is "pfifo_fast".  */
+static int prio_parse_opt(int argc, char **argv, struct nlmsghdr *n)
+{
+	return 0;
+}
+static int prio_print_opt(struct rtattr *opt)
+{
+	int i;
+	struct tc_prio_qopt *qopt;
+	struct rtattr *tb[TCA_PRIO_MAX+1];
+
+	if (opt == NULL)
+		return 0;
+	parse_rtattr_nested_compat(tb, TCA_PRIO_MAX, opt, qopt, sizeof(*qopt));
+	if (tb == NULL)
+		return 0;
+	printf("bands %u priomap ", qopt->bands);
+	for (i=0; i<=TC_PRIO_MAX; i++)
+		printf(" %d", qopt->priomap[i]);
+
+	if (tb[TCA_PRIO_MQ])
+		printf(" multiqueue: o%s ",
+		    *(unsigned char *)RTA_DATA(tb[TCA_PRIO_MQ]) ? "n" : "ff");
+
+	return 0;
+}
+
+/* Class Based Queue */
+static int cbq_parse_opt(int argc, char **argv, struct nlmsghdr *n)
+{
+	return 0;
+}
+static int cbq_print_opt(struct rtattr *opt)
+{
+	struct rtattr *tb[TCA_CBQ_MAX+1];
+	struct tc_ratespec *r = NULL;
+	struct tc_cbq_lssopt *lss = NULL;
+	struct tc_cbq_wrropt *wrr = NULL;
+	struct tc_cbq_fopt *fopt = NULL;
+	struct tc_cbq_ovl *ovl = NULL;
+	const char * const error = "CBQ: too short %s opt";
+	RESERVE_CONFIG_BUFFER(buf, 64);
+
+	if (opt == NULL)
+		goto done;
+	parse_rtattr_nested(tb, TCA_CBQ_MAX, opt);
+
+	if (tb[TCA_CBQ_RATE]) {
+		if (RTA_PAYLOAD(tb[TCA_CBQ_RATE]) < sizeof(*r))
+			bb_error_msg(error, "rate");
+		else
+			r = RTA_DATA(tb[TCA_CBQ_RATE]);
+	}
+	if (tb[TCA_CBQ_LSSOPT]) {
+		if (RTA_PAYLOAD(tb[TCA_CBQ_LSSOPT]) < sizeof(*lss))
+			bb_error_msg(error, "lss");
+		else
+			lss = RTA_DATA(tb[TCA_CBQ_LSSOPT]);
+	}
+	if (tb[TCA_CBQ_WRROPT]) {
+		if (RTA_PAYLOAD(tb[TCA_CBQ_WRROPT]) < sizeof(*wrr))
+			bb_error_msg(error, "wrr");
+		else
+			wrr = RTA_DATA(tb[TCA_CBQ_WRROPT]);
+	}
+	if (tb[TCA_CBQ_FOPT]) {
+		if (RTA_PAYLOAD(tb[TCA_CBQ_FOPT]) < sizeof(*fopt))
+			bb_error_msg(error, "fopt");
+		else
+			fopt = RTA_DATA(tb[TCA_CBQ_FOPT]);
+	}
+	if (tb[TCA_CBQ_OVL_STRATEGY]) {
+		if (RTA_PAYLOAD(tb[TCA_CBQ_OVL_STRATEGY]) < sizeof(*ovl))
+			bb_error_msg("CBQ: too short overlimit strategy %u/%u",
+				(unsigned) RTA_PAYLOAD(tb[TCA_CBQ_OVL_STRATEGY]),
+				(unsigned) sizeof(*ovl));
+		else
+			ovl = RTA_DATA(tb[TCA_CBQ_OVL_STRATEGY]);
+	}
+
+	if (r) {
+		print_rate(buf, sizeof(buf), r->rate);
+		printf("rate %s ", buf);
+		if (show_details) {
+			printf("cell %ub ", 1<<r->cell_log);
+			if (r->mpu)
+				printf("mpu %ub ", r->mpu);
+			if (r->overhead)
+				printf("overhead %ub ", r->overhead);
+		}
+	}
+	if (lss && lss->flags) {
+		bool comma = false;
+		bb_putchar('(');
+		if (lss->flags&TCF_CBQ_LSS_BOUNDED) {
+			printf("bounded");
+			comma = true;
+		}
+		if (lss->flags&TCF_CBQ_LSS_ISOLATED) {
+			if (comma)
+				bb_putchar(',');
+			printf("isolated");
+		}
+		printf(") ");
+	}
+	if (wrr) {
+		if (wrr->priority != TC_CBQ_MAXPRIO)
+			printf("prio %u", wrr->priority);
+		else
+			printf("prio no-transmit");
+		if (show_details) {
+			printf("/%u ", wrr->cpriority);
+			if (wrr->weight != 1) {
+				print_rate(buf, sizeof(buf), wrr->weight);
+				printf("weight %s ", buf);
+			}
+			if (wrr->allot)
+				printf("allot %ub ", wrr->allot);
+		}
+	}
+ done:
+	RELEASE_CONFIG_BUFFER(buf);
+	return 0;
+}
+
+static int print_qdisc(const struct sockaddr_nl *who UNUSED_PARAM,
+						struct nlmsghdr *hdr, void *arg UNUSED_PARAM)
+{
+	struct tcmsg *msg = NLMSG_DATA(hdr);
+	int len = hdr->nlmsg_len;
+	struct rtattr * tb[TCA_MAX+1];
+	char *name;
+
+	if (hdr->nlmsg_type != RTM_NEWQDISC && hdr->nlmsg_type != RTM_DELQDISC) {
+		/* bb_error_msg("Not a qdisc"); */
+		return 0; /* ??? mimic upstream; should perhaps return -1 */
+	}
+	len -= NLMSG_LENGTH(sizeof(*msg));
+	if (len < 0) {
+		/* bb_error_msg("Wrong len %d", len); */
+		return -1;
+	}
+	/* not the desired interface? */
+	if (filter_ifindex && filter_ifindex != msg->tcm_ifindex)
+		return 0;
+	memset (tb, 0, sizeof(tb));
+	parse_rtattr(tb, TCA_MAX, TCA_RTA(msg), len);
+	if (tb[TCA_KIND] == NULL) {
+		/* bb_error_msg("%s: NULL kind", "qdisc"); */
+		return -1;
+	}
+	if (hdr->nlmsg_type == RTM_DELQDISC)
+		printf("deleted ");
+	name = (char*)RTA_DATA(tb[TCA_KIND]);
+	printf("qdisc %s %x: ", name, msg->tcm_handle>>16);
+	if (filter_ifindex == 0)
+		printf("dev %s ", ll_index_to_name(msg->tcm_ifindex));
+	if (msg->tcm_parent == TC_H_ROOT)
+		printf("root ");
+	else if (msg->tcm_parent) {
+		char *classid = print_tc_classid(msg->tcm_parent);
+		printf("parent %s ", classid);
+		if (ENABLE_FEATURE_CLEAN_UP)
+			free(classid);
+	}
+	if (msg->tcm_info != 1)
+		printf("refcnt %d ", msg->tcm_info);
+	if (tb[TCA_OPTIONS]) {
+		static const char _q_[] ALIGN1 = "pfifo_fast\0""cbq\0";
+		int qqq = index_in_strings(_q_, name);
+		if (qqq == 0) { /* pfifo_fast aka prio */
+			prio_print_opt(tb[TCA_OPTIONS]);
+		} else if (qqq == 1) { /* class based queueing */
+			cbq_print_opt(tb[TCA_OPTIONS]);
+		} else
+			bb_error_msg("unknown %s", name);
+	}
+	bb_putchar('\n');
+	return 0;
+}
+
+static int print_class(const struct sockaddr_nl *who UNUSED_PARAM,
+						struct nlmsghdr *hdr, void *arg UNUSED_PARAM)
+{
+	struct tcmsg *msg = NLMSG_DATA(hdr);
+	int len = hdr->nlmsg_len;
+	struct rtattr * tb[TCA_MAX+1];
+	char *name, *classid;
+
+	/*XXX Eventually factor out common code */
+
+	if (hdr->nlmsg_type != RTM_NEWTCLASS && hdr->nlmsg_type != RTM_DELTCLASS) {
+		/* bb_error_msg("Not a class"); */
+		return 0; /* ??? mimic upstream; should perhaps return -1 */
+	}
+	len -= NLMSG_LENGTH(sizeof(*msg));
+	if (len < 0) {
+		/* bb_error_msg("Wrong len %d", len); */
+		return -1;
+	}
+	/* not the desired interface? */
+	if (filter_qdisc && TC_H_MAJ(msg->tcm_handle^filter_qdisc))
+		return 0;
+	memset (tb, 0, sizeof(tb));
+	parse_rtattr(tb, TCA_MAX, TCA_RTA(msg), len);
+	if (tb[TCA_KIND] == NULL) {
+		/* bb_error_msg("%s: NULL kind", "class"); */
+		return -1;
+	}
+	if (hdr->nlmsg_type == RTM_DELTCLASS)
+		printf("deleted ");
+
+	name = (char*)RTA_DATA(tb[TCA_KIND]);
+	classid = !msg->tcm_handle ? NULL : print_tc_classid(
+				filter_qdisc ? TC_H_MIN(msg->tcm_parent) : msg->tcm_parent);
+	printf ("class %s %s", name, classid);
+	if (ENABLE_FEATURE_CLEAN_UP)
+		free(classid);
+
+	if (filter_ifindex == 0)
+		printf("dev %s ", ll_index_to_name(msg->tcm_ifindex));
+	if (msg->tcm_parent == TC_H_ROOT)
+		printf("root ");
+	else if (msg->tcm_parent) {
+		classid = print_tc_classid(filter_qdisc ?
+								   TC_H_MIN(msg->tcm_parent) : msg->tcm_parent);
+		printf("parent %s ", classid);
+		if (ENABLE_FEATURE_CLEAN_UP)
+			free(classid);
+	}
+	if (msg->tcm_info)
+		printf("leaf %x ", msg->tcm_info >> 16);
+	/* Do that get_qdisc_kind(RTA_DATA(tb[TCA_KIND])).  */
+	if (tb[TCA_OPTIONS]) {
+		static const char _q_[] ALIGN1 = "pfifo_fast\0""cbq\0";
+		int qqq = index_in_strings(_q_, name);
+		if (qqq == 0) { /* pfifo_fast aka prio */
+			/* nothing. */ /*prio_print_opt(tb[TCA_OPTIONS]);*/
+		} else if (qqq == 1) { /* class based queueing */
+			/* cbq_print_copt() is identical to cbq_print_opt(). */
+			cbq_print_opt(tb[TCA_OPTIONS]);
+		} else
+			bb_error_msg("unknown %s", name);
+	}
+	bb_putchar('\n');
+
+	return 0;
+}
+
+static int print_filter(const struct sockaddr_nl *who UNUSED_PARAM,
+						struct nlmsghdr *hdr, void *arg UNUSED_PARAM)
+{
+	struct tcmsg *msg = NLMSG_DATA(hdr);
+	int len = hdr->nlmsg_len;
+	struct rtattr * tb[TCA_MAX+1];
+	return 0;
+}
+
+int tc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int tc_main(int argc UNUSED_PARAM, char **argv)
+{
+	static const char objects[] ALIGN1 =
+		"qdisc\0""class\0""filter\0"
+		;
+	enum { OBJ_qdisc = 0, OBJ_class, OBJ_filter };
+	static const char commands[] ALIGN1 =
+		"add\0""delete\0""change\0"
+		"link\0" /* only qdisc */
+		"replace\0"
+		"show\0""list\0"
+		;
+	static const char args[] ALIGN1 =
+		"dev\0" /* qdisc, class, filter */
+		"root\0" /* class, filter */
+		"parent\0" /* class, filter */
+		"qdisc\0" /* class */
+		"handle\0" /* change: qdisc, class(classid) list: filter */
+		"classid\0" /* change: for class use "handle" */
+		"preference\0""priority\0""protocol\0" /* filter */
+		;
+	enum { CMD_add = 0, CMD_del, CMD_change, CMD_link, CMD_replace, CMD_show };
+	enum { ARG_dev = 0, ARG_root, ARG_parent, ARG_qdisc,
+			ARG_handle, ARG_classid, ARG_pref, ARG_prio, ARG_proto};
+	struct rtnl_handle rth;
+	struct tcmsg msg;
+	int ret, obj, cmd, arg;
+	char *dev = NULL;
+
+	INIT_G();
+
+	if (!*++argv)
+		bb_show_usage();
+	xrtnl_open(&rth);
+	ret = EXIT_SUCCESS;
+
+	obj = index_in_substrings(objects, *argv++);
+
+	if (obj < OBJ_qdisc)
+		bb_show_usage();
+	if (!*argv)
+		cmd = CMD_show; /* list is the default */
+	else {
+		cmd = index_in_substrings(commands, *argv);
+		if (cmd < 0)
+			bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
+		argv++;
+	}
+	memset(&msg, 0, sizeof(msg));
+	msg.tcm_family = AF_UNSPEC;
+	ll_init_map(&rth);
+	while (*argv) {
+		arg = index_in_substrings(args, *argv);
+		if (arg == ARG_dev) {
+			NEXT_ARG();
+			if (dev)
+				duparg2("dev", *argv);
+			dev = *argv++;
+			msg.tcm_ifindex = xll_name_to_index(dev);
+			if (cmd >= CMD_show)
+				filter_ifindex = msg.tcm_ifindex;
+		} else if ((arg == ARG_qdisc && obj == OBJ_class && cmd >= CMD_show)
+				   || (arg == ARG_handle && obj == OBJ_qdisc
+					   && cmd == CMD_change)) {
+			NEXT_ARG();
+			/* We don't care about duparg2("qdisc handle",*argv) for now */
+			if (get_qdisc_handle(&filter_qdisc, *argv))
+				invarg(*argv, "qdisc");
+		} else if (obj != OBJ_qdisc &&
+				   (arg == ARG_root
+					 || arg == ARG_parent
+					 || (obj == OBJ_filter && arg >= ARG_pref))) {
+		} else {
+			invarg(*argv, "command");
+		}
+		NEXT_ARG();
+		if (arg == ARG_root) {
+			if (msg.tcm_parent)
+				duparg("parent", *argv);
+			msg.tcm_parent = TC_H_ROOT;
+			if (obj == OBJ_filter)
+				filter_parent = TC_H_ROOT;
+		} else if (arg == ARG_parent) {
+			__u32 handle;
+			if (msg.tcm_parent)
+				duparg(*argv, "parent");
+			if (get_tc_classid(&handle, *argv))
+				invarg(*argv, "parent");
+			msg.tcm_parent = handle;
+			if (obj == OBJ_filter)
+				filter_parent = handle;
+		} else if (arg == ARG_handle) { /* filter::list */
+			if (msg.tcm_handle)
+				duparg(*argv, "handle");
+			/* reject LONG_MIN || LONG_MAX */
+			/* TODO: for fw
+			   if ((slash = strchr(handle, '/')) != NULL)
+				   *slash = '\0';
+			 */
+			if (get_u32(&msg.tcm_handle, *argv, 0))
+				invarg(*argv, "handle");
+			/* if (slash) {if (get_u32(__u32 &mask, slash+1,0)) inv mask;addattr32(n, MAX_MSG, TCA_FW_MASK, mask); */
+		} else if (arg == ARG_classid && obj == OBJ_class && cmd == CMD_change){
+		} else if (arg == ARG_pref || arg == ARG_prio) { /* filter::list */
+			if (filter_prio)
+				duparg(*argv, "priority");
+			if (get_u32(&filter_prio, *argv, 0))
+				invarg(*argv, "priority");
+		} else if (arg == ARG_proto) { /* filter::list */
+			__u16 tmp;
+			if (filter_proto)
+				duparg(*argv, "protocol");
+			if (ll_proto_a2n(&tmp, *argv))
+				invarg(*argv, "protocol");
+			filter_proto = tmp;
+		}
+	}
+	if (cmd >= CMD_show) { /* show or list */
+		if (obj == OBJ_filter)
+			msg.tcm_info = TC_H_MAKE(filter_prio<<16, filter_proto);
+		if (rtnl_dump_request(&rth, obj == OBJ_qdisc ? RTM_GETQDISC :
+						obj == OBJ_class ? RTM_GETTCLASS : RTM_GETTFILTER,
+						&msg, sizeof(msg)) < 0)
+			bb_simple_perror_msg_and_die("cannot send dump request");
+
+		xrtnl_dump_filter(&rth, obj == OBJ_qdisc ? print_qdisc :
+						obj == OBJ_class ? print_class : print_filter,
+						NULL);
+	}
+	if (ENABLE_FEATURE_CLEAN_UP) {
+		rtnl_close(&rth);
+	}
+	return ret;
+}