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