1 /*
2 * tc_util.c Misc TC utility functions.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
8 *
9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 *
11 */
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <unistd.h>
16 #include <syslog.h>
17 #include <fcntl.h>
18 #include <sys/socket.h>
19 #include <netinet/in.h>
20 #include <arpa/inet.h>
21 #include <string.h>
22 #include <math.h>
23
24 #include "utils.h"
25 #include "tc_util.h"
26
27 #ifndef LIBDIR
28 #define LIBDIR "/usr/lib/"
29 #endif
30
get_tc_lib(void)31 const char *get_tc_lib(void)
32 {
33 const char *lib_dir;
34
35 lib_dir = getenv("TC_LIB_DIR");
36 if (!lib_dir)
37 lib_dir = LIBDIR "/tc/";
38
39 return lib_dir;
40 }
41
get_qdisc_handle(__u32 * h,const char * str)42 int get_qdisc_handle(__u32 *h, const char *str)
43 {
44 __u32 maj;
45 char *p;
46
47 maj = TC_H_UNSPEC;
48 if (strcmp(str, "none") == 0)
49 goto ok;
50 maj = strtoul(str, &p, 16);
51 if (p == str)
52 return -1;
53 maj <<= 16;
54 if (*p != ':' && *p!=0)
55 return -1;
56 ok:
57 *h = maj;
58 return 0;
59 }
60
get_tc_classid(__u32 * h,const char * str)61 int get_tc_classid(__u32 *h, const char *str)
62 {
63 __u32 maj, min;
64 char *p;
65
66 maj = TC_H_ROOT;
67 if (strcmp(str, "root") == 0)
68 goto ok;
69 maj = TC_H_UNSPEC;
70 if (strcmp(str, "none") == 0)
71 goto ok;
72 maj = strtoul(str, &p, 16);
73 if (p == str) {
74 maj = 0;
75 if (*p != ':')
76 return -1;
77 }
78 if (*p == ':') {
79 if (maj >= (1<<16))
80 return -1;
81 maj <<= 16;
82 str = p+1;
83 min = strtoul(str, &p, 16);
84 if (*p != 0)
85 return -1;
86 if (min >= (1<<16))
87 return -1;
88 maj |= min;
89 } else if (*p != 0)
90 return -1;
91
92 ok:
93 *h = maj;
94 return 0;
95 }
96
print_tc_classid(char * buf,int len,__u32 h)97 int print_tc_classid(char *buf, int len, __u32 h)
98 {
99 if (h == TC_H_ROOT)
100 sprintf(buf, "root");
101 else if (h == TC_H_UNSPEC)
102 snprintf(buf, len, "none");
103 else if (TC_H_MAJ(h) == 0)
104 snprintf(buf, len, ":%x", TC_H_MIN(h));
105 else if (TC_H_MIN(h) == 0)
106 snprintf(buf, len, "%x:", TC_H_MAJ(h)>>16);
107 else
108 snprintf(buf, len, "%x:%x", TC_H_MAJ(h)>>16, TC_H_MIN(h));
109 return 0;
110 }
111
sprint_tc_classid(__u32 h,char * buf)112 char * sprint_tc_classid(__u32 h, char *buf)
113 {
114 if (print_tc_classid(buf, SPRINT_BSIZE-1, h))
115 strcpy(buf, "???");
116 return buf;
117 }
118
119 /* See http://physics.nist.gov/cuu/Units/binary.html */
120 static const struct rate_suffix {
121 const char *name;
122 double scale;
123 } suffixes[] = {
124 { "bit", 1. },
125 { "Kibit", 1024. },
126 { "kbit", 1000. },
127 { "mibit", 1024.*1024. },
128 { "mbit", 1000000. },
129 { "gibit", 1024.*1024.*1024. },
130 { "gbit", 1000000000. },
131 { "tibit", 1024.*1024.*1024.*1024. },
132 { "tbit", 1000000000000. },
133 { "Bps", 8. },
134 { "KiBps", 8.*1024. },
135 { "KBps", 8000. },
136 { "MiBps", 8.*1024*1024. },
137 { "MBps", 8000000. },
138 { "GiBps", 8.*1024.*1024.*1024. },
139 { "GBps", 8000000000. },
140 { "TiBps", 8.*1024.*1024.*1024.*1024. },
141 { "TBps", 8000000000000. },
142 { NULL }
143 };
144
145
get_rate(unsigned * rate,const char * str)146 int get_rate(unsigned *rate, const char *str)
147 {
148 char *p;
149 double bps = strtod(str, &p);
150 const struct rate_suffix *s;
151
152 if (p == str)
153 return -1;
154
155 if (*p == '\0') {
156 *rate = bps / 8.; /* assume bytes/sec */
157 return 0;
158 }
159
160 for (s = suffixes; s->name; ++s) {
161 if (strcasecmp(s->name, p) == 0) {
162 *rate = (bps * s->scale) / 8.;
163 return 0;
164 }
165 }
166
167 return -1;
168 }
169
get_rate_and_cell(unsigned * rate,int * cell_log,char * str)170 int get_rate_and_cell(unsigned *rate, int *cell_log, char *str)
171 {
172 char * slash = strchr(str, '/');
173
174 if (slash)
175 *slash = 0;
176
177 if (get_rate(rate, str))
178 return -1;
179
180 if (slash) {
181 int cell;
182 int i;
183
184 if (get_integer(&cell, slash+1, 0))
185 return -1;
186 *slash = '/';
187
188 for (i=0; i<32; i++) {
189 if ((1<<i) == cell) {
190 *cell_log = i;
191 return 0;
192 }
193 }
194 return -1;
195 }
196 return 0;
197 }
198
print_rate(char * buf,int len,__u32 rate)199 void print_rate(char *buf, int len, __u32 rate)
200 {
201 double tmp = (double)rate*8;
202 extern int use_iec;
203
204 if (use_iec) {
205 if (tmp >= 1000.0*1024.0*1024.0)
206 snprintf(buf, len, "%.0fMibit", tmp/1024.0*1024.0);
207 else if (tmp >= 1000.0*1024)
208 snprintf(buf, len, "%.0fKibit", tmp/1024);
209 else
210 snprintf(buf, len, "%.0fbit", tmp);
211 } else {
212 if (tmp >= 1000.0*1000000.0)
213 snprintf(buf, len, "%.0fMbit", tmp/1000000.0);
214 else if (tmp >= 1000.0 * 1000.0)
215 snprintf(buf, len, "%.0fKbit", tmp/1000.0);
216 else
217 snprintf(buf, len, "%.0fbit", tmp);
218 }
219 }
220
sprint_rate(__u32 rate,char * buf)221 char * sprint_rate(__u32 rate, char *buf)
222 {
223 print_rate(buf, SPRINT_BSIZE-1, rate);
224 return buf;
225 }
226
get_time(unsigned * time,const char * str)227 int get_time(unsigned *time, const char *str)
228 {
229 double t;
230 char *p;
231
232 t = strtod(str, &p);
233 if (p == str)
234 return -1;
235
236 if (*p) {
237 if (strcasecmp(p, "s") == 0 || strcasecmp(p, "sec")==0 ||
238 strcasecmp(p, "secs")==0)
239 t *= TIME_UNITS_PER_SEC;
240 else if (strcasecmp(p, "ms") == 0 || strcasecmp(p, "msec")==0 ||
241 strcasecmp(p, "msecs") == 0)
242 t *= TIME_UNITS_PER_SEC/1000;
243 else if (strcasecmp(p, "us") == 0 || strcasecmp(p, "usec")==0 ||
244 strcasecmp(p, "usecs") == 0)
245 t *= TIME_UNITS_PER_SEC/1000000;
246 else
247 return -1;
248 }
249
250 *time = t;
251 return 0;
252 }
253
254
print_time(char * buf,int len,__u32 time)255 void print_time(char *buf, int len, __u32 time)
256 {
257 double tmp = time;
258
259 if (tmp >= TIME_UNITS_PER_SEC)
260 snprintf(buf, len, "%.1fs", tmp/TIME_UNITS_PER_SEC);
261 else if (tmp >= TIME_UNITS_PER_SEC/1000)
262 snprintf(buf, len, "%.1fms", tmp/(TIME_UNITS_PER_SEC/1000));
263 else
264 snprintf(buf, len, "%uus", time);
265 }
266
sprint_time(__u32 time,char * buf)267 char * sprint_time(__u32 time, char *buf)
268 {
269 print_time(buf, SPRINT_BSIZE-1, time);
270 return buf;
271 }
272
sprint_ticks(__u32 ticks,char * buf)273 char * sprint_ticks(__u32 ticks, char *buf)
274 {
275 return sprint_time(tc_core_tick2time(ticks), buf);
276 }
277
get_size(unsigned * size,const char * str)278 int get_size(unsigned *size, const char *str)
279 {
280 double sz;
281 char *p;
282
283 sz = strtod(str, &p);
284 if (p == str)
285 return -1;
286
287 if (*p) {
288 if (strcasecmp(p, "kb") == 0 || strcasecmp(p, "k")==0)
289 sz *= 1024;
290 else if (strcasecmp(p, "gb") == 0 || strcasecmp(p, "g")==0)
291 sz *= 1024*1024*1024;
292 else if (strcasecmp(p, "gbit") == 0)
293 sz *= 1024*1024*1024/8;
294 else if (strcasecmp(p, "mb") == 0 || strcasecmp(p, "m")==0)
295 sz *= 1024*1024;
296 else if (strcasecmp(p, "mbit") == 0)
297 sz *= 1024*1024/8;
298 else if (strcasecmp(p, "kbit") == 0)
299 sz *= 1024/8;
300 else if (strcasecmp(p, "b") != 0)
301 return -1;
302 }
303
304 *size = sz;
305 return 0;
306 }
307
get_size_and_cell(unsigned * size,int * cell_log,char * str)308 int get_size_and_cell(unsigned *size, int *cell_log, char *str)
309 {
310 char * slash = strchr(str, '/');
311
312 if (slash)
313 *slash = 0;
314
315 if (get_size(size, str))
316 return -1;
317
318 if (slash) {
319 int cell;
320 int i;
321
322 if (get_integer(&cell, slash+1, 0))
323 return -1;
324 *slash = '/';
325
326 for (i=0; i<32; i++) {
327 if ((1<<i) == cell) {
328 *cell_log = i;
329 return 0;
330 }
331 }
332 return -1;
333 }
334 return 0;
335 }
336
print_size(char * buf,int len,__u32 sz)337 void print_size(char *buf, int len, __u32 sz)
338 {
339 double tmp = sz;
340
341 if (sz >= 1024*1024 && fabs(1024*1024*rint(tmp/(1024*1024)) - sz) < 1024)
342 snprintf(buf, len, "%gMb", rint(tmp/(1024*1024)));
343 else if (sz >= 1024 && fabs(1024*rint(tmp/1024) - sz) < 16)
344 snprintf(buf, len, "%gKb", rint(tmp/1024));
345 else
346 snprintf(buf, len, "%ub", sz);
347 }
348
sprint_size(__u32 size,char * buf)349 char * sprint_size(__u32 size, char *buf)
350 {
351 print_size(buf, SPRINT_BSIZE-1, size);
352 return buf;
353 }
354
355 static const double max_percent_value = 0xffffffff;
356
get_percent(__u32 * percent,const char * str)357 int get_percent(__u32 *percent, const char *str)
358 {
359 char *p;
360 double per = strtod(str, &p) / 100.;
361
362 if (per > 1. || per < 0)
363 return -1;
364 if (*p && strcmp(p, "%"))
365 return -1;
366
367 *percent = (unsigned) rint(per * max_percent_value);
368 return 0;
369 }
370
print_percent(char * buf,int len,__u32 per)371 void print_percent(char *buf, int len, __u32 per)
372 {
373 snprintf(buf, len, "%g%%", 100. * (double) per / max_percent_value);
374 }
375
sprint_percent(__u32 per,char * buf)376 char * sprint_percent(__u32 per, char *buf)
377 {
378 print_percent(buf, SPRINT_BSIZE-1, per);
379 return buf;
380 }
381
print_qdisc_handle(char * buf,int len,__u32 h)382 void print_qdisc_handle(char *buf, int len, __u32 h)
383 {
384 snprintf(buf, len, "%x:", TC_H_MAJ(h)>>16);
385 }
386
sprint_qdisc_handle(__u32 h,char * buf)387 char * sprint_qdisc_handle(__u32 h, char *buf)
388 {
389 print_qdisc_handle(buf, SPRINT_BSIZE-1, h);
390 return buf;
391 }
392
action_n2a(int action,char * buf,int len)393 char * action_n2a(int action, char *buf, int len)
394 {
395 switch (action) {
396 case -1:
397 return "continue";
398 break;
399 case TC_ACT_OK:
400 return "pass";
401 break;
402 case TC_ACT_SHOT:
403 return "drop";
404 break;
405 case TC_ACT_RECLASSIFY:
406 return "reclassify";
407 case TC_ACT_PIPE:
408 return "pipe";
409 case TC_ACT_STOLEN:
410 return "stolen";
411 default:
412 snprintf(buf, len, "%d", action);
413 return buf;
414 }
415 }
416
action_a2n(char * arg,int * result)417 int action_a2n(char *arg, int *result)
418 {
419 int res;
420
421 if (matches(arg, "continue") == 0)
422 res = -1;
423 else if (matches(arg, "drop") == 0)
424 res = TC_ACT_SHOT;
425 else if (matches(arg, "shot") == 0)
426 res = TC_ACT_SHOT;
427 else if (matches(arg, "pass") == 0)
428 res = TC_ACT_OK;
429 else if (strcmp(arg, "ok") == 0)
430 res = TC_ACT_OK;
431 else if (matches(arg, "reclassify") == 0)
432 res = TC_ACT_RECLASSIFY;
433 else {
434 char dummy;
435 if (sscanf(arg, "%d%c", &res, &dummy) != 1)
436 return -1;
437 }
438 *result = res;
439 return 0;
440 }
441
get_linklayer(unsigned * val,const char * arg)442 int get_linklayer(unsigned *val, const char *arg)
443 {
444 int res;
445
446 if (matches(arg, "ethernet") == 0)
447 res = LINKLAYER_ETHERNET;
448 else if (matches(arg, "atm") == 0)
449 res = LINKLAYER_ATM;
450 else if (matches(arg, "adsl") == 0)
451 res = LINKLAYER_ATM;
452 else
453 return -1; /* Indicate error */
454
455 *val = res;
456 return 0;
457 }
458
print_linklayer(char * buf,int len,unsigned linklayer)459 void print_linklayer(char *buf, int len, unsigned linklayer)
460 {
461 switch (linklayer) {
462 case LINKLAYER_UNSPEC:
463 snprintf(buf, len, "%s", "unspec");
464 return;
465 case LINKLAYER_ETHERNET:
466 snprintf(buf, len, "%s", "ethernet");
467 return;
468 case LINKLAYER_ATM:
469 snprintf(buf, len, "%s", "atm");
470 return;
471 default:
472 snprintf(buf, len, "%s", "unknown");
473 return;
474 }
475 }
476
sprint_linklayer(unsigned linklayer,char * buf)477 char *sprint_linklayer(unsigned linklayer, char *buf)
478 {
479 print_linklayer(buf, SPRINT_BSIZE-1, linklayer);
480 return buf;
481 }
482
print_tm(FILE * f,const struct tcf_t * tm)483 void print_tm(FILE * f, const struct tcf_t *tm)
484 {
485 int hz = get_user_hz();
486 if (tm->install != 0)
487 fprintf(f, " installed %u sec", (unsigned)(tm->install/hz));
488 if (tm->lastuse != 0)
489 fprintf(f, " used %u sec", (unsigned)(tm->lastuse/hz));
490 if (tm->expires != 0)
491 fprintf(f, " expires %u sec", (unsigned)(tm->expires/hz));
492 }
493
print_tcstats2_attr(FILE * fp,struct rtattr * rta,char * prefix,struct rtattr ** xstats)494 void print_tcstats2_attr(FILE *fp, struct rtattr *rta, char *prefix, struct rtattr **xstats)
495 {
496 SPRINT_BUF(b1);
497 struct rtattr *tbs[TCA_STATS_MAX + 1];
498
499 parse_rtattr_nested(tbs, TCA_STATS_MAX, rta);
500
501 if (tbs[TCA_STATS_BASIC]) {
502 struct gnet_stats_basic bs = {0};
503 memcpy(&bs, RTA_DATA(tbs[TCA_STATS_BASIC]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_BASIC]), sizeof(bs)));
504 fprintf(fp, "%sSent %llu bytes %u pkt",
505 prefix, (unsigned long long) bs.bytes, bs.packets);
506 }
507
508 if (tbs[TCA_STATS_QUEUE]) {
509 struct gnet_stats_queue q = {0};
510 memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
511 fprintf(fp, " (dropped %u, overlimits %u requeues %u) ",
512 q.drops, q.overlimits, q.requeues);
513 }
514
515 if (tbs[TCA_STATS_RATE_EST]) {
516 struct gnet_stats_rate_est re = {0};
517 memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST]), sizeof(re)));
518 fprintf(fp, "\n%srate %s %upps ",
519 prefix, sprint_rate(re.bps, b1), re.pps);
520 }
521
522 if (tbs[TCA_STATS_QUEUE]) {
523 struct gnet_stats_queue q = {0};
524 memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
525 if (!tbs[TCA_STATS_RATE_EST])
526 fprintf(fp, "\n%s", prefix);
527 fprintf(fp, "backlog %s %up requeues %u ",
528 sprint_size(q.backlog, b1), q.qlen, q.requeues);
529 }
530
531 if (xstats)
532 *xstats = tbs[TCA_STATS_APP] ? : NULL;
533 }
534
print_tcstats_attr(FILE * fp,struct rtattr * tb[],char * prefix,struct rtattr ** xstats)535 void print_tcstats_attr(FILE *fp, struct rtattr *tb[], char *prefix, struct rtattr **xstats)
536 {
537 SPRINT_BUF(b1);
538
539 if (tb[TCA_STATS2]) {
540 print_tcstats2_attr(fp, tb[TCA_STATS2], prefix, xstats);
541 if (xstats && NULL == *xstats)
542 goto compat_xstats;
543 return;
544 }
545 /* backward compatibility */
546 if (tb[TCA_STATS]) {
547 struct tc_stats st;
548
549 /* handle case where kernel returns more/less than we know about */
550 memset(&st, 0, sizeof(st));
551 memcpy(&st, RTA_DATA(tb[TCA_STATS]), MIN(RTA_PAYLOAD(tb[TCA_STATS]), sizeof(st)));
552
553 fprintf(fp, "%sSent %llu bytes %u pkts (dropped %u, overlimits %u) ",
554 prefix, (unsigned long long)st.bytes, st.packets, st.drops,
555 st.overlimits);
556
557 if (st.bps || st.pps || st.qlen || st.backlog) {
558 fprintf(fp, "\n%s", prefix);
559 if (st.bps || st.pps) {
560 fprintf(fp, "rate ");
561 if (st.bps)
562 fprintf(fp, "%s ", sprint_rate(st.bps, b1));
563 if (st.pps)
564 fprintf(fp, "%upps ", st.pps);
565 }
566 if (st.qlen || st.backlog) {
567 fprintf(fp, "backlog ");
568 if (st.backlog)
569 fprintf(fp, "%s ", sprint_size(st.backlog, b1));
570 if (st.qlen)
571 fprintf(fp, "%up ", st.qlen);
572 }
573 }
574 }
575
576 compat_xstats:
577 if (tb[TCA_XSTATS] && xstats)
578 *xstats = tb[TCA_XSTATS];
579 }
580
581