source: MondoRescue/branches/2.2.9/mindi-busybox/networking/tc.c@ 2725

Last change on this file since 2725 was 2725, checked in by Bruno Cornec, 13 years ago
  • Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3
  • Property svn:eol-style set to native
File size: 14.3 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
4 *
5 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
6 *
7 * Bernhard Reutner-Fischer adjusted for busybox
8 */
9
10#include "libbb.h"
11
12#include "libiproute/utils.h"
13#include "libiproute/ip_common.h"
14#include "libiproute/rt_names.h"
15#include <linux/pkt_sched.h> /* for the TC_H_* macros */
16
17#define parse_rtattr_nested(tb, max, rta) \
18 (parse_rtattr((tb), (max), RTA_DATA(rta), RTA_PAYLOAD(rta)))
19
20/* nullifies tb on error */
21#define __parse_rtattr_nested_compat(tb, max, rta, len) \
22 ({if ((RTA_PAYLOAD(rta) >= len) && \
23 (RTA_PAYLOAD(rta) >= RTA_ALIGN(len) + sizeof(struct rtattr))) { \
24 rta = RTA_DATA(rta) + RTA_ALIGN(len); \
25 parse_rtattr_nested(tb, max, rta); \
26 } else \
27 memset(tb, 0, sizeof(struct rtattr *) * (max + 1)); \
28 })
29
30#define parse_rtattr_nested_compat(tb, max, rta, data, len) \
31 ({data = RTA_PAYLOAD(rta) >= len ? RTA_DATA(rta) : NULL; \
32 __parse_rtattr_nested_compat(tb, max, rta, len); })
33
34#define show_details (0) /* not implemented. Does anyone need it? */
35#define use_iec (0) /* not currently documented in the upstream manpage */
36
37
38struct globals {
39 int filter_ifindex;
40 __u32 filter_qdisc;
41 __u32 filter_parent;
42 __u32 filter_prio;
43 __u32 filter_proto;
44} FIX_ALIASING;
45#define G (*(struct globals*)&bb_common_bufsiz1)
46#define filter_ifindex (G.filter_ifindex)
47#define filter_qdisc (G.filter_qdisc)
48#define filter_parent (G.filter_parent)
49#define filter_prio (G.filter_prio)
50#define filter_proto (G.filter_proto)
51
52void BUG_tc_globals_too_big(void);
53#define INIT_G() do { \
54 if (sizeof(G) > COMMON_BUFSIZE) \
55 BUG_tc_globals_too_big(); \
56} while (0)
57
58/* Allocates a buffer containing the name of a class id.
59 * The caller must free the returned memory. */
60static char* print_tc_classid(uint32_t cid)
61{
62#if 0 /* IMPOSSIBLE */
63 if (cid == TC_H_ROOT)
64 return xasprintf("root");
65 else
66#endif
67 if (cid == TC_H_UNSPEC)
68 return xasprintf("none");
69 else if (TC_H_MAJ(cid) == 0)
70 return xasprintf(":%x", TC_H_MIN(cid));
71 else if (TC_H_MIN(cid) == 0)
72 return xasprintf("%x:", TC_H_MAJ(cid)>>16);
73 else
74 return xasprintf("%x:%x", TC_H_MAJ(cid)>>16, TC_H_MIN(cid));
75}
76
77/* Get a qdisc handle. Return 0 on success, !0 otherwise. */
78static int get_qdisc_handle(__u32 *h, const char *str) {
79 __u32 maj;
80 char *p;
81
82 maj = TC_H_UNSPEC;
83 if (!strcmp(str, "none"))
84 goto ok;
85 maj = strtoul(str, &p, 16);
86 if (p == str)
87 return 1;
88 maj <<= 16;
89 if (*p != ':' && *p != '\0')
90 return 1;
91 ok:
92 *h = maj;
93 return 0;
94}
95
96/* Get class ID. Return 0 on success, !0 otherwise. */
97static int get_tc_classid(__u32 *h, const char *str) {
98 __u32 maj, min;
99 char *p;
100
101 maj = TC_H_ROOT;
102 if (!strcmp(str, "root"))
103 goto ok;
104 maj = TC_H_UNSPEC;
105 if (!strcmp(str, "none"))
106 goto ok;
107 maj = strtoul(str, &p, 16);
108 if (p == str) {
109 if (*p != ':')
110 return 1;
111 maj = 0;
112 }
113 if (*p == ':') {
114 if (maj >= (1<<16))
115 return 1;
116 maj <<= 16;
117 str = p + 1;
118 min = strtoul(str, &p, 16);
119//FIXME: check for "" too?
120 if (*p != '\0' || min >= (1<<16))
121 return 1;
122 maj |= min;
123 } else if (*p != 0)
124 return 1;
125 ok:
126 *h = maj;
127 return 0;
128}
129
130static void print_rate(char *buf, int len, uint32_t rate)
131{
132 double tmp = (double)rate*8;
133
134 if (use_iec) {
135 if (tmp >= 1000.0*1024.0*1024.0)
136 snprintf(buf, len, "%.0fMibit", tmp/1024.0*1024.0);
137 else if (tmp >= 1000.0*1024)
138 snprintf(buf, len, "%.0fKibit", tmp/1024);
139 else
140 snprintf(buf, len, "%.0fbit", tmp);
141 } else {
142 if (tmp >= 1000.0*1000000.0)
143 snprintf(buf, len, "%.0fMbit", tmp/1000000.0);
144 else if (tmp >= 1000.0 * 1000.0)
145 snprintf(buf, len, "%.0fKbit", tmp/1000.0);
146 else
147 snprintf(buf, len, "%.0fbit", tmp);
148 }
149}
150
151/* This is "pfifo_fast". */
152static int prio_parse_opt(int argc, char **argv, struct nlmsghdr *n)
153{
154 return 0;
155}
156static int prio_print_opt(struct rtattr *opt)
157{
158 int i;
159 struct tc_prio_qopt *qopt;
160 struct rtattr *tb[TCA_PRIO_MAX+1];
161
162 if (opt == NULL)
163 return 0;
164 parse_rtattr_nested_compat(tb, TCA_PRIO_MAX, opt, qopt, sizeof(*qopt));
165 if (tb == NULL)
166 return 0;
167 printf("bands %u priomap ", qopt->bands);
168 for (i=0; i<=TC_PRIO_MAX; i++)
169 printf(" %d", qopt->priomap[i]);
170
171 if (tb[TCA_PRIO_MQ])
172 printf(" multiqueue: o%s ",
173 *(unsigned char *)RTA_DATA(tb[TCA_PRIO_MQ]) ? "n" : "ff");
174
175 return 0;
176}
177
178/* Class Based Queue */
179static int cbq_parse_opt(int argc, char **argv, struct nlmsghdr *n)
180{
181 return 0;
182}
183static int cbq_print_opt(struct rtattr *opt)
184{
185 struct rtattr *tb[TCA_CBQ_MAX+1];
186 struct tc_ratespec *r = NULL;
187 struct tc_cbq_lssopt *lss = NULL;
188 struct tc_cbq_wrropt *wrr = NULL;
189 struct tc_cbq_fopt *fopt = NULL;
190 struct tc_cbq_ovl *ovl = NULL;
191 const char *const error = "CBQ: too short %s opt";
192 char buf[64];
193
194 if (opt == NULL)
195 goto done;
196 parse_rtattr_nested(tb, TCA_CBQ_MAX, opt);
197
198 if (tb[TCA_CBQ_RATE]) {
199 if (RTA_PAYLOAD(tb[TCA_CBQ_RATE]) < sizeof(*r))
200 bb_error_msg(error, "rate");
201 else
202 r = RTA_DATA(tb[TCA_CBQ_RATE]);
203 }
204 if (tb[TCA_CBQ_LSSOPT]) {
205 if (RTA_PAYLOAD(tb[TCA_CBQ_LSSOPT]) < sizeof(*lss))
206 bb_error_msg(error, "lss");
207 else
208 lss = RTA_DATA(tb[TCA_CBQ_LSSOPT]);
209 }
210 if (tb[TCA_CBQ_WRROPT]) {
211 if (RTA_PAYLOAD(tb[TCA_CBQ_WRROPT]) < sizeof(*wrr))
212 bb_error_msg(error, "wrr");
213 else
214 wrr = RTA_DATA(tb[TCA_CBQ_WRROPT]);
215 }
216 if (tb[TCA_CBQ_FOPT]) {
217 if (RTA_PAYLOAD(tb[TCA_CBQ_FOPT]) < sizeof(*fopt))
218 bb_error_msg(error, "fopt");
219 else
220 fopt = RTA_DATA(tb[TCA_CBQ_FOPT]);
221 }
222 if (tb[TCA_CBQ_OVL_STRATEGY]) {
223 if (RTA_PAYLOAD(tb[TCA_CBQ_OVL_STRATEGY]) < sizeof(*ovl))
224 bb_error_msg("CBQ: too short overlimit strategy %u/%u",
225 (unsigned) RTA_PAYLOAD(tb[TCA_CBQ_OVL_STRATEGY]),
226 (unsigned) sizeof(*ovl));
227 else
228 ovl = RTA_DATA(tb[TCA_CBQ_OVL_STRATEGY]);
229 }
230
231 if (r) {
232 print_rate(buf, sizeof(buf), r->rate);
233 printf("rate %s ", buf);
234 if (show_details) {
235 printf("cell %ub ", 1<<r->cell_log);
236 if (r->mpu)
237 printf("mpu %ub ", r->mpu);
238 if (r->overhead)
239 printf("overhead %ub ", r->overhead);
240 }
241 }
242 if (lss && lss->flags) {
243 bool comma = false;
244 bb_putchar('(');
245 if (lss->flags&TCF_CBQ_LSS_BOUNDED) {
246 printf("bounded");
247 comma = true;
248 }
249 if (lss->flags&TCF_CBQ_LSS_ISOLATED) {
250 if (comma)
251 bb_putchar(',');
252 printf("isolated");
253 }
254 printf(") ");
255 }
256 if (wrr) {
257 if (wrr->priority != TC_CBQ_MAXPRIO)
258 printf("prio %u", wrr->priority);
259 else
260 printf("prio no-transmit");
261 if (show_details) {
262 printf("/%u ", wrr->cpriority);
263 if (wrr->weight != 1) {
264 print_rate(buf, sizeof(buf), wrr->weight);
265 printf("weight %s ", buf);
266 }
267 if (wrr->allot)
268 printf("allot %ub ", wrr->allot);
269 }
270 }
271 done:
272 return 0;
273}
274
275static int print_qdisc(const struct sockaddr_nl *who UNUSED_PARAM,
276 struct nlmsghdr *hdr, void *arg UNUSED_PARAM)
277{
278 struct tcmsg *msg = NLMSG_DATA(hdr);
279 int len = hdr->nlmsg_len;
280 struct rtattr * tb[TCA_MAX+1];
281 char *name;
282
283 if (hdr->nlmsg_type != RTM_NEWQDISC && hdr->nlmsg_type != RTM_DELQDISC) {
284 /* bb_error_msg("not a qdisc"); */
285 return 0; /* ??? mimic upstream; should perhaps return -1 */
286 }
287 len -= NLMSG_LENGTH(sizeof(*msg));
288 if (len < 0) {
289 /* bb_error_msg("wrong len %d", len); */
290 return -1;
291 }
292 /* not the desired interface? */
293 if (filter_ifindex && filter_ifindex != msg->tcm_ifindex)
294 return 0;
295 memset (tb, 0, sizeof(tb));
296 parse_rtattr(tb, TCA_MAX, TCA_RTA(msg), len);
297 if (tb[TCA_KIND] == NULL) {
298 /* bb_error_msg("%s: NULL kind", "qdisc"); */
299 return -1;
300 }
301 if (hdr->nlmsg_type == RTM_DELQDISC)
302 printf("deleted ");
303 name = (char*)RTA_DATA(tb[TCA_KIND]);
304 printf("qdisc %s %x: ", name, msg->tcm_handle>>16);
305 if (filter_ifindex == 0)
306 printf("dev %s ", ll_index_to_name(msg->tcm_ifindex));
307 if (msg->tcm_parent == TC_H_ROOT)
308 printf("root ");
309 else if (msg->tcm_parent) {
310 char *classid = print_tc_classid(msg->tcm_parent);
311 printf("parent %s ", classid);
312 if (ENABLE_FEATURE_CLEAN_UP)
313 free(classid);
314 }
315 if (msg->tcm_info != 1)
316 printf("refcnt %d ", msg->tcm_info);
317 if (tb[TCA_OPTIONS]) {
318 static const char _q_[] ALIGN1 = "pfifo_fast\0""cbq\0";
319 int qqq = index_in_strings(_q_, name);
320 if (qqq == 0) { /* pfifo_fast aka prio */
321 prio_print_opt(tb[TCA_OPTIONS]);
322 } else if (qqq == 1) { /* class based queuing */
323 cbq_print_opt(tb[TCA_OPTIONS]);
324 } else
325 bb_error_msg("unknown %s", name);
326 }
327 bb_putchar('\n');
328 return 0;
329}
330
331static int print_class(const struct sockaddr_nl *who UNUSED_PARAM,
332 struct nlmsghdr *hdr, void *arg UNUSED_PARAM)
333{
334 struct tcmsg *msg = NLMSG_DATA(hdr);
335 int len = hdr->nlmsg_len;
336 struct rtattr * tb[TCA_MAX+1];
337 char *name, *classid;
338
339 /*XXX Eventually factor out common code */
340
341 if (hdr->nlmsg_type != RTM_NEWTCLASS && hdr->nlmsg_type != RTM_DELTCLASS) {
342 /* bb_error_msg("not a class"); */
343 return 0; /* ??? mimic upstream; should perhaps return -1 */
344 }
345 len -= NLMSG_LENGTH(sizeof(*msg));
346 if (len < 0) {
347 /* bb_error_msg("wrong len %d", len); */
348 return -1;
349 }
350 /* not the desired interface? */
351 if (filter_qdisc && TC_H_MAJ(msg->tcm_handle^filter_qdisc))
352 return 0;
353 memset (tb, 0, sizeof(tb));
354 parse_rtattr(tb, TCA_MAX, TCA_RTA(msg), len);
355 if (tb[TCA_KIND] == NULL) {
356 /* bb_error_msg("%s: NULL kind", "class"); */
357 return -1;
358 }
359 if (hdr->nlmsg_type == RTM_DELTCLASS)
360 printf("deleted ");
361
362 name = (char*)RTA_DATA(tb[TCA_KIND]);
363 classid = !msg->tcm_handle ? NULL : print_tc_classid(
364 filter_qdisc ? TC_H_MIN(msg->tcm_parent) : msg->tcm_parent);
365 printf ("class %s %s", name, classid);
366 if (ENABLE_FEATURE_CLEAN_UP)
367 free(classid);
368
369 if (filter_ifindex == 0)
370 printf("dev %s ", ll_index_to_name(msg->tcm_ifindex));
371 if (msg->tcm_parent == TC_H_ROOT)
372 printf("root ");
373 else if (msg->tcm_parent) {
374 classid = print_tc_classid(filter_qdisc ?
375 TC_H_MIN(msg->tcm_parent) : msg->tcm_parent);
376 printf("parent %s ", classid);
377 if (ENABLE_FEATURE_CLEAN_UP)
378 free(classid);
379 }
380 if (msg->tcm_info)
381 printf("leaf %x ", msg->tcm_info >> 16);
382 /* Do that get_qdisc_kind(RTA_DATA(tb[TCA_KIND])). */
383 if (tb[TCA_OPTIONS]) {
384 static const char _q_[] ALIGN1 = "pfifo_fast\0""cbq\0";
385 int qqq = index_in_strings(_q_, name);
386 if (qqq == 0) { /* pfifo_fast aka prio */
387 /* nothing. */ /*prio_print_opt(tb[TCA_OPTIONS]);*/
388 } else if (qqq == 1) { /* class based queuing */
389 /* cbq_print_copt() is identical to cbq_print_opt(). */
390 cbq_print_opt(tb[TCA_OPTIONS]);
391 } else
392 bb_error_msg("unknown %s", name);
393 }
394 bb_putchar('\n');
395
396 return 0;
397}
398
399static int print_filter(const struct sockaddr_nl *who UNUSED_PARAM,
400 struct nlmsghdr *hdr, void *arg UNUSED_PARAM)
401{
402 struct tcmsg *msg = NLMSG_DATA(hdr);
403 int len = hdr->nlmsg_len;
404 struct rtattr * tb[TCA_MAX+1];
405 return 0;
406}
407
408int tc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
409int tc_main(int argc UNUSED_PARAM, char **argv)
410{
411 static const char objects[] ALIGN1 =
412 "qdisc\0""class\0""filter\0"
413 ;
414 enum { OBJ_qdisc = 0, OBJ_class, OBJ_filter };
415 static const char commands[] ALIGN1 =
416 "add\0""delete\0""change\0"
417 "link\0" /* only qdisc */
418 "replace\0"
419 "show\0""list\0"
420 ;
421 static const char args[] ALIGN1 =
422 "dev\0" /* qdisc, class, filter */
423 "root\0" /* class, filter */
424 "parent\0" /* class, filter */
425 "qdisc\0" /* class */
426 "handle\0" /* change: qdisc, class(classid) list: filter */
427 "classid\0" /* change: for class use "handle" */
428 "preference\0""priority\0""protocol\0" /* filter */
429 ;
430 enum { CMD_add = 0, CMD_del, CMD_change, CMD_link, CMD_replace, CMD_show };
431 enum { ARG_dev = 0, ARG_root, ARG_parent, ARG_qdisc,
432 ARG_handle, ARG_classid, ARG_pref, ARG_prio, ARG_proto};
433 struct rtnl_handle rth;
434 struct tcmsg msg;
435 int ret, obj, cmd, arg;
436 char *dev = NULL;
437
438 INIT_G();
439
440 if (!*++argv)
441 bb_show_usage();
442 xrtnl_open(&rth);
443 ret = EXIT_SUCCESS;
444
445 obj = index_in_substrings(objects, *argv++);
446
447 if (obj < OBJ_qdisc)
448 bb_show_usage();
449 if (!*argv)
450 cmd = CMD_show; /* list is the default */
451 else {
452 cmd = index_in_substrings(commands, *argv);
453 if (cmd < 0)
454 bb_error_msg_and_die(bb_msg_invalid_arg, *argv, applet_name);
455 argv++;
456 }
457 memset(&msg, 0, sizeof(msg));
458 msg.tcm_family = AF_UNSPEC;
459 ll_init_map(&rth);
460 while (*argv) {
461 arg = index_in_substrings(args, *argv);
462 if (arg == ARG_dev) {
463 NEXT_ARG();
464 if (dev)
465 duparg2("dev", *argv);
466 dev = *argv++;
467 msg.tcm_ifindex = xll_name_to_index(dev);
468 if (cmd >= CMD_show)
469 filter_ifindex = msg.tcm_ifindex;
470 } else
471 if ((arg == ARG_qdisc && obj == OBJ_class && cmd >= CMD_show)
472 || (arg == ARG_handle && obj == OBJ_qdisc && cmd == CMD_change)
473 ) {
474 NEXT_ARG();
475 /* We don't care about duparg2("qdisc handle",*argv) for now */
476 if (get_qdisc_handle(&filter_qdisc, *argv))
477 invarg(*argv, "qdisc");
478 } else
479 if (obj != OBJ_qdisc
480 && (arg == ARG_root
481 || arg == ARG_parent
482 || (obj == OBJ_filter && arg >= ARG_pref)
483 )
484 ) {
485 /* nothing */
486 } else {
487 invarg(*argv, "command");
488 }
489 NEXT_ARG();
490 if (arg == ARG_root) {
491 if (msg.tcm_parent)
492 duparg("parent", *argv);
493 msg.tcm_parent = TC_H_ROOT;
494 if (obj == OBJ_filter)
495 filter_parent = TC_H_ROOT;
496 } else if (arg == ARG_parent) {
497 __u32 handle;
498 if (msg.tcm_parent)
499 duparg(*argv, "parent");
500 if (get_tc_classid(&handle, *argv))
501 invarg(*argv, "parent");
502 msg.tcm_parent = handle;
503 if (obj == OBJ_filter)
504 filter_parent = handle;
505 } else if (arg == ARG_handle) { /* filter::list */
506 if (msg.tcm_handle)
507 duparg(*argv, "handle");
508 /* reject LONG_MIN || LONG_MAX */
509 /* TODO: for fw
510 if ((slash = strchr(handle, '/')) != NULL)
511 *slash = '\0';
512 */
513 msg.tcm_handle = get_u32(*argv, "handle");
514 /* if (slash) {if (get_u32(__u32 &mask, slash+1, NULL)) inv mask; addattr32(n, MAX_MSG, TCA_FW_MASK, mask); */
515 } else if (arg == ARG_classid && obj == OBJ_class && cmd == CMD_change){
516 } else if (arg == ARG_pref || arg == ARG_prio) { /* filter::list */
517 if (filter_prio)
518 duparg(*argv, "priority");
519 filter_prio = get_u32(*argv, "priority");
520 } else if (arg == ARG_proto) { /* filter::list */
521 uint16_t tmp;
522 if (filter_proto)
523 duparg(*argv, "protocol");
524 if (ll_proto_a2n(&tmp, *argv))
525 invarg(*argv, "protocol");
526 filter_proto = tmp;
527 }
528 }
529 if (cmd >= CMD_show) { /* show or list */
530 if (obj == OBJ_filter)
531 msg.tcm_info = TC_H_MAKE(filter_prio<<16, filter_proto);
532 if (rtnl_dump_request(&rth, obj == OBJ_qdisc ? RTM_GETQDISC :
533 obj == OBJ_class ? RTM_GETTCLASS : RTM_GETTFILTER,
534 &msg, sizeof(msg)) < 0)
535 bb_simple_perror_msg_and_die("can't send dump request");
536
537 xrtnl_dump_filter(&rth, obj == OBJ_qdisc ? print_qdisc :
538 obj == OBJ_class ? print_class : print_filter,
539 NULL);
540 }
541 if (ENABLE_FEATURE_CLEAN_UP) {
542 rtnl_close(&rth);
543 }
544 return ret;
545}
Note: See TracBrowser for help on using the repository browser.