[mirror_iproute2.git] / tc / tc_util.c

/*
 * tc_util.c		Misc TC utility functions.
 *
 *		This program is free software; you can redistribute it and/or
 *		modify it under the terms of the GNU General Public License
 *		as published by the Free Software Foundation; either version
 *		2 of the License, or (at your option) any later version.
 *
 * Authors:	Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/param.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <math.h>
#include <errno.h>

#include "utils.h"
#include "names.h"
#include "tc_util.h"
#include "tc_common.h"

#ifndef LIBDIR
#define LIBDIR "/usr/lib"
#endif

static struct db_names *cls_names = NULL;

#define NAMES_DB "/etc/iproute2/tc_cls"

int cls_names_init(char *path)
{
	int ret;

	cls_names = db_names_alloc();
	if (!cls_names)
		return -1;

	ret = db_names_load(cls_names, path ?: NAMES_DB);
	if (ret == -ENOENT && path) {
		fprintf(stderr, "Can't open class names file: %s\n", path);
		return -1;
	}
	if (ret) {
		db_names_free(cls_names);
		cls_names = NULL;
	}

	return 0;
}

void cls_names_uninit(void)
{
	db_names_free(cls_names);
}

const char *get_tc_lib(void)
{
	const char *lib_dir;

	lib_dir = getenv("TC_LIB_DIR");
	if (!lib_dir)
		lib_dir = LIBDIR "/tc/";

	return lib_dir;
}

int get_qdisc_handle(__u32 *h, const char *str)
{
	__u32 maj;
	char *p;

	maj = TC_H_UNSPEC;
	if (strcmp(str, "none") == 0)
		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;
}

int get_tc_classid(__u32 *h, const char *str)
{
	__u32 maj, min;
	char *p;

	maj = TC_H_ROOT;
	if (strcmp(str, "root") == 0)
		goto ok;
	maj = TC_H_UNSPEC;
	if (strcmp(str, "none") == 0)
		goto ok;
	maj = strtoul(str, &p, 16);
	if (p == str) {
		maj = 0;
		if (*p != ':')
			return -1;
	}
	if (*p == ':') {
		if (maj >= (1<<16))
			return -1;
		maj <<= 16;
		str = p+1;
		min = strtoul(str, &p, 16);
		if (*p != 0)
			return -1;
		if (min >= (1<<16))
			return -1;
		maj |= min;
	} else if (*p != 0)
		return -1;

ok:
	*h = maj;
	return 0;
}

int print_tc_classid(char *buf, int blen, __u32 h)
{
	SPRINT_BUF(handle) = {};
	int hlen = SPRINT_BSIZE - 1;

	if (h == TC_H_ROOT)
		sprintf(handle, "root");
	else if (h == TC_H_UNSPEC)
		snprintf(handle, hlen, "none");
	else if (TC_H_MAJ(h) == 0)
		snprintf(handle, hlen, ":%x", TC_H_MIN(h));
	else if (TC_H_MIN(h) == 0)
		snprintf(handle, hlen, "%x:", TC_H_MAJ(h) >> 16);
	else
		snprintf(handle, hlen, "%x:%x", TC_H_MAJ(h) >> 16, TC_H_MIN(h));

	if (use_names) {
		char clname[IDNAME_MAX] = {};

		if (id_to_name(cls_names, h, clname))
			snprintf(buf, blen, "%s#%s", clname, handle);
		else
			snprintf(buf, blen, "%s", handle);
	} else {
		snprintf(buf, blen, "%s", handle);
	}

	return 0;
}

char *sprint_tc_classid(__u32 h, char *buf)
{
	if (print_tc_classid(buf, SPRINT_BSIZE-1, h))
		strcpy(buf, "???");
	return buf;
}

/* See http://physics.nist.gov/cuu/Units/binary.html */
static const struct rate_suffix {
	const char *name;
	double scale;
} suffixes[] = {
	{ "bit",	1. },
	{ "Kibit",	1024. },
	{ "kbit",	1000. },
	{ "mibit",	1024.*1024. },
	{ "mbit",	1000000. },
	{ "gibit",	1024.*1024.*1024. },
	{ "gbit",	1000000000. },
	{ "tibit",	1024.*1024.*1024.*1024. },
	{ "tbit",	1000000000000. },
	{ "Bps",	8. },
	{ "KiBps",	8.*1024. },
	{ "KBps",	8000. },
	{ "MiBps",	8.*1024*1024. },
	{ "MBps",	8000000. },
	{ "GiBps",	8.*1024.*1024.*1024. },
	{ "GBps",	8000000000. },
	{ "TiBps",	8.*1024.*1024.*1024.*1024. },
	{ "TBps",	8000000000000. },
	{ NULL }
};


int get_rate(unsigned *rate, const char *str)
{
	char *p;
	double bps = strtod(str, &p);
	const struct rate_suffix *s;

	if (p == str)
		return -1;

	for (s = suffixes; s->name; ++s) {
		if (strcasecmp(s->name, p) == 0) {
			bps *= s->scale;
			p += strlen(p);
			break;
		}
	}

	if (*p)
		return -1; /* unknown suffix */

	bps /= 8; /* -> bytes per second */
	*rate = bps;
	/* detect if an overflow happened */
	if (*rate != floor(bps))
		return -1;
	return 0;
}

int get_rate64(__u64 *rate, const char *str)
{
	char *p;
	double bps = strtod(str, &p);
	const struct rate_suffix *s;

	if (p == str)
		return -1;

	for (s = suffixes; s->name; ++s) {
		if (strcasecmp(s->name, p) == 0) {
			bps *= s->scale;
			p += strlen(p);
			break;
		}
	}

	if (*p)
		return -1; /* unknown suffix */

	bps /= 8; /* -> bytes per second */
	*rate = bps;
	return 0;
}

void print_rate(char *buf, int len, __u64 rate)
{
	extern int use_iec;
	unsigned long kilo = use_iec ? 1024 : 1000;
	const char *str = use_iec ? "i" : "";
	static char *units[5] = {"", "K", "M", "G", "T"};
	int i;

	rate <<= 3; /* bytes/sec -> bits/sec */

	for (i = 0; i < ARRAY_SIZE(units) - 1; i++)  {
		if (rate < kilo)
			break;
		if (((rate % kilo) != 0) && rate < 1000*kilo)
			break;
		rate /= kilo;
	}

	snprintf(buf, len, "%.0f%s%sbit", (double)rate, units[i], str);
}

char * sprint_rate(__u64 rate, char *buf)
{
	print_rate(buf, SPRINT_BSIZE-1, rate);
	return buf;
}

int get_time(unsigned *time, const char *str)
{
	double t;
	char *p;

	t = strtod(str, &p);
	if (p == str)
		return -1;

	if (*p) {
		if (strcasecmp(p, "s") == 0 || strcasecmp(p, "sec")==0 ||
		    strcasecmp(p, "secs")==0)
			t *= TIME_UNITS_PER_SEC;
		else if (strcasecmp(p, "ms") == 0 || strcasecmp(p, "msec")==0 ||
			 strcasecmp(p, "msecs") == 0)
			t *= TIME_UNITS_PER_SEC/1000;
		else if (strcasecmp(p, "us") == 0 || strcasecmp(p, "usec")==0 ||
			 strcasecmp(p, "usecs") == 0)
			t *= TIME_UNITS_PER_SEC/1000000;
		else
			return -1;
	}

	*time = t;
	return 0;
}


void print_time(char *buf, int len, __u32 time)
{
	double tmp = time;

	if (tmp >= TIME_UNITS_PER_SEC)
		snprintf(buf, len, "%.1fs", tmp/TIME_UNITS_PER_SEC);
	else if (tmp >= TIME_UNITS_PER_SEC/1000)
		snprintf(buf, len, "%.1fms", tmp/(TIME_UNITS_PER_SEC/1000));
	else
		snprintf(buf, len, "%uus", time);
}

char * sprint_time(__u32 time, char *buf)
{
	print_time(buf, SPRINT_BSIZE-1, time);
	return buf;
}

char * sprint_ticks(__u32 ticks, char *buf)
{
	return sprint_time(tc_core_tick2time(ticks), buf);
}

int get_size(unsigned *size, const char *str)
{
	double sz;
	char *p;

	sz = strtod(str, &p);
	if (p == str)
		return -1;

	if (*p) {
		if (strcasecmp(p, "kb") == 0 || strcasecmp(p, "k")==0)
			sz *= 1024;
		else if (strcasecmp(p, "gb") == 0 || strcasecmp(p, "g")==0)
			sz *= 1024*1024*1024;
		else if (strcasecmp(p, "gbit") == 0)
			sz *= 1024*1024*1024/8;
		else if (strcasecmp(p, "mb") == 0 || strcasecmp(p, "m")==0)
			sz *= 1024*1024;
		else if (strcasecmp(p, "mbit") == 0)
			sz *= 1024*1024/8;
		else if (strcasecmp(p, "kbit") == 0)
			sz *= 1024/8;
		else if (strcasecmp(p, "b") != 0)
			return -1;
	}

	*size = sz;
	return 0;
}

int get_size_and_cell(unsigned *size, int *cell_log, char *str)
{
	char * slash = strchr(str, '/');

	if (slash)
		*slash = 0;

	if (get_size(size, str))
		return -1;

	if (slash) {
		int cell;
		int i;

		if (get_integer(&cell, slash+1, 0))
			return -1;
		*slash = '/';

		for (i=0; i<32; i++) {
			if ((1<<i) == cell) {
				*cell_log = i;
				return 0;
			}
		}
		return -1;
	}
	return 0;
}

void print_size(char *buf, int len, __u32 sz)
{
	double tmp = sz;

	if (sz >= 1024*1024 && fabs(1024*1024*rint(tmp/(1024*1024)) - sz) < 1024)
		snprintf(buf, len, "%gMb", rint(tmp/(1024*1024)));
	else if (sz >= 1024 && fabs(1024*rint(tmp/1024) - sz) < 16)
		snprintf(buf, len, "%gKb", rint(tmp/1024));
	else
		snprintf(buf, len, "%ub", sz);
}

char * sprint_size(__u32 size, char *buf)
{
	print_size(buf, SPRINT_BSIZE-1, size);
	return buf;
}

void print_qdisc_handle(char *buf, int len, __u32 h)
{
	snprintf(buf, len, "%x:", TC_H_MAJ(h)>>16);
}

char * sprint_qdisc_handle(__u32 h, char *buf)
{
	print_qdisc_handle(buf, SPRINT_BSIZE-1, h);
	return buf;
}

char * action_n2a(int action, char *buf, int len)
{
	switch (action) {
	case -1:
		return "continue";
		break;
	case TC_ACT_OK:
		return "pass";
		break;
	case TC_ACT_SHOT:
		return "drop";
		break;
	case TC_ACT_RECLASSIFY:
		return "reclassify";
	case TC_ACT_PIPE:
		return "pipe";
	case TC_ACT_STOLEN:
		return "stolen";
	default:
		snprintf(buf, len, "%d", action);
		return buf;
	}
}

int action_a2n(char *arg, int *result)
{
	int res;

	if (matches(arg, "continue") == 0)
		res = -1;
	else if (matches(arg, "drop") == 0)
		res = TC_ACT_SHOT;
	else if (matches(arg, "shot") == 0)
		res = TC_ACT_SHOT;
	else if (matches(arg, "pass") == 0)
		res = TC_ACT_OK;
	else if (strcmp(arg, "ok") == 0)
		res = TC_ACT_OK;
	else if (matches(arg, "reclassify") == 0)
		res = TC_ACT_RECLASSIFY;
	else {
		char dummy;
		if (sscanf(arg, "%d%c", &res, &dummy) != 1)
			return -1;
	}
	*result = res;
	return 0;
}

int get_linklayer(unsigned *val, const char *arg)
{
	int res;

	if (matches(arg, "ethernet") == 0)
		res = LINKLAYER_ETHERNET;
	else if (matches(arg, "atm") == 0)
		res = LINKLAYER_ATM;
	else if (matches(arg, "adsl") == 0)
		res = LINKLAYER_ATM;
	else
		return -1; /* Indicate error */

	*val = res;
	return 0;
}

void print_linklayer(char *buf, int len, unsigned linklayer)
{
	switch (linklayer) {
	case LINKLAYER_UNSPEC:
		snprintf(buf, len, "%s", "unspec");
		return;
	case LINKLAYER_ETHERNET:
		snprintf(buf, len, "%s", "ethernet");
		return;
	case LINKLAYER_ATM:
		snprintf(buf, len, "%s", "atm");
		return;
	default:
		snprintf(buf, len, "%s", "unknown");
		return;
	}
}

char *sprint_linklayer(unsigned linklayer, char *buf)
{
	print_linklayer(buf, SPRINT_BSIZE-1, linklayer);
	return buf;
}

void print_tm(FILE * f, const struct tcf_t *tm)
{
	int hz = get_user_hz();
	if (tm->install != 0)
		fprintf(f, " installed %u sec", (unsigned)(tm->install/hz));
	if (tm->lastuse != 0)
		fprintf(f, " used %u sec", (unsigned)(tm->lastuse/hz));
	if (tm->expires != 0)
		fprintf(f, " expires %u sec", (unsigned)(tm->expires/hz));
}

void print_tcstats2_attr(FILE *fp, struct rtattr *rta, char *prefix, struct rtattr **xstats)
{
	SPRINT_BUF(b1);
	struct rtattr *tbs[TCA_STATS_MAX + 1];

	parse_rtattr_nested(tbs, TCA_STATS_MAX, rta);

	if (tbs[TCA_STATS_BASIC]) {
		struct gnet_stats_basic bs = {0};
		memcpy(&bs, RTA_DATA(tbs[TCA_STATS_BASIC]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_BASIC]), sizeof(bs)));
		fprintf(fp, "%sSent %llu bytes %u pkt",
			prefix, (unsigned long long) bs.bytes, bs.packets);
	}

	if (tbs[TCA_STATS_QUEUE]) {
		struct gnet_stats_queue q = {0};
		memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
		fprintf(fp, " (dropped %u, overlimits %u requeues %u) ",
			q.drops, q.overlimits, q.requeues);
	}

	if (tbs[TCA_STATS_RATE_EST64]) {
		struct gnet_stats_rate_est64 re = {0};

		memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST64]),
		       MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST64]),
			   sizeof(re)));
		fprintf(fp, "\n%srate %s %llupps ",
			prefix, sprint_rate(re.bps, b1), re.pps);
	} else if (tbs[TCA_STATS_RATE_EST]) {
		struct gnet_stats_rate_est re = {0};

		memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST]),
		       MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST]), sizeof(re)));
		fprintf(fp, "\n%srate %s %upps ",
			prefix, sprint_rate(re.bps, b1), re.pps);
	}

	if (tbs[TCA_STATS_QUEUE]) {
		struct gnet_stats_queue q = {0};
		memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
		if (!tbs[TCA_STATS_RATE_EST])
			fprintf(fp, "\n%s", prefix);
		fprintf(fp, "backlog %s %up requeues %u ",
			sprint_size(q.backlog, b1), q.qlen, q.requeues);
	}

	if (xstats)
		*xstats = tbs[TCA_STATS_APP] ? : NULL;
}

void print_tcstats_attr(FILE *fp, struct rtattr *tb[], char *prefix, struct rtattr **xstats)
{
	SPRINT_BUF(b1);

	if (tb[TCA_STATS2]) {
		print_tcstats2_attr(fp, tb[TCA_STATS2], prefix, xstats);
		if (xstats && NULL == *xstats)
			goto compat_xstats;
		return;
	}
	/* backward compatibility */
	if (tb[TCA_STATS]) {
		struct tc_stats st;

		/* handle case where kernel returns more/less than we know about */
		memset(&st, 0, sizeof(st));
		memcpy(&st, RTA_DATA(tb[TCA_STATS]), MIN(RTA_PAYLOAD(tb[TCA_STATS]), sizeof(st)));

		fprintf(fp, "%sSent %llu bytes %u pkts (dropped %u, overlimits %u) ",
			prefix, (unsigned long long)st.bytes, st.packets, st.drops,
			st.overlimits);

		if (st.bps || st.pps || st.qlen || st.backlog) {
			fprintf(fp, "\n%s", prefix);
			if (st.bps || st.pps) {
				fprintf(fp, "rate ");
				if (st.bps)
					fprintf(fp, "%s ", sprint_rate(st.bps, b1));
				if (st.pps)
					fprintf(fp, "%upps ", st.pps);
			}
			if (st.qlen || st.backlog) {
				fprintf(fp, "backlog ");
				if (st.backlog)
					fprintf(fp, "%s ", sprint_size(st.backlog, b1));
				if (st.qlen)
					fprintf(fp, "%up ", st.qlen);
			}
		}
	}

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