diff options
Diffstat (limited to 'release/src/router/busybox/networking/tc.c')
| -rw-r--r-- | release/src/router/busybox/networking/tc.c | 543 |
1 files changed, 543 insertions, 0 deletions
diff --git a/release/src/router/busybox/networking/tc.c b/release/src/router/busybox/networking/tc.c new file mode 100644 index 00000000..03f57f63 --- /dev/null +++ b/release/src/router/busybox/networking/tc.c @@ -0,0 +1,543 @@ +/* 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 Reutner-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'; + */ + msg.tcm_handle = get_u32(*argv, "handle"); + /* if (slash) {if (get_u32(__u32 &mask, slash+1, NULL)) 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"); + filter_prio = get_u32(*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; +} |