[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 <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <math.h>

#include "utils.h"
#include "tc_util.h"

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

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 len, __u32 h)
{
	if (h == TC_H_ROOT)
		sprintf(buf, "root");
	else if (h == TC_H_UNSPEC)
		snprintf(buf, len, "none");
	else if (TC_H_MAJ(h) == 0)
		snprintf(buf, len, ":%x", TC_H_MIN(h));
	else if (TC_H_MIN(h) == 0)
		snprintf(buf, len, "%x:", TC_H_MAJ(h)>>16);
	else
		snprintf(buf, len, "%x:%x", TC_H_MAJ(h)>>16, TC_H_MIN(h));
	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;
}

void print_rate(char *buf, int len, __u64 rate)
{
	double tmp = (double)rate*8;
	extern int use_iec;

	if (use_iec) {
		if (tmp >= 1000.0*1024.0*1024.0*1024.0)
			snprintf(buf, len, "%.0fGibit", tmp/(1024.0*1024.0*1024.0));
		else 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*1000000000.0)
			snprintf(buf, len, "%.0fGbit", tmp/1000000000.0);
		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);
	}
}

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>
	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
5e3bb534	27	#ifndef LIBDIR
5c434a9e	28	#define LIBDIR "/usr/lib"
b514b358 RA	29	#endif
b514b358 RA	30
aa27f88c SH	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)
5e3bb534	37	lib_dir = LIBDIR "/tc/";
aa27f88c SH	38
	39	return lib_dir;
	40	}
	41
dbd90dc2	42	int get_qdisc_handle(__u32 h, const char str)
aba5acdf SH	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
dbd90dc2	61	int get_tc_classid(__u32 h, const char str)
aba5acdf SH	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 == ':') {
a8b303cc SH	79	if (maj >= (1<<16))
a8b303cc SH	80	return -1;
aba5acdf SH	81	maj <<= 16;
	82	str = p+1;
	83	min = strtoul(str, &p, 16);
	84	if (*p != 0)
	85	return -1;
a8b303cc SH	86	if (min >= (1<<16))
a8b303cc SH	87	return -1;
aba5acdf SH	88	maj \|= min;
	89	} else if (*p != 0)
	90	return -1;
	91
	92	ok:
	93	*h = maj;
	94	return 0;
	95	}
	96
	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
	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
26ab0b10 SH	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.10241024. },
	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
dbd90dc2	146	int get_rate(unsigned rate, const char str)
aba5acdf SH	147	{
	148	char *p;
	149	double bps = strtod(str, &p);
26ab0b10	150	const struct rate_suffix *s;
aba5acdf SH	151
	152	if (p == str)
	153	return -1;
	154
26ab0b10 SH	155	for (s = suffixes; s->name; ++s) {
26ab0b10 SH	156	if (strcasecmp(s->name, p) == 0) {
a303853e ED	157	bps *= s->scale;
	158	p += strlen(p);
	159	break;
26ab0b10 SH	160	}
	161	}
	162
a303853e ED	163	if (*p)
	164	return -1; /* unknown suffix */
	165
	166	bps /= 8; /* -> bytes per second */
	167	*rate = bps;
	168	/* detect if an overflow happened */
	169	if (*rate != floor(bps))
	170	return -1;
	171	return 0;
aba5acdf SH	172	}
aba5acdf SH	173
8f7574ed	174	void print_rate(char *buf, int len, __u64 rate)
aba5acdf SH	175	{
aba5acdf SH	176	double tmp = (double)rate*8;
d40b38b4 SH	177	extern int use_iec;
	178
	179	if (use_iec) {
8f7574ed ED	180	if (tmp >= 1000.01024.01024.0*1024.0)
	181	snprintf(buf, len, "%.0fGibit", tmp/(1024.01024.01024.0));
	182	else if (tmp >= 1000.01024.01024.0)
f526af99	183	snprintf(buf, len, "%.0fMibit", tmp/(1024.0*1024.0));
abf1d0b0 SH	184	else if (tmp >= 1000.0*1024)
abf1d0b0 SH	185	snprintf(buf, len, "%.0fKibit", tmp/1024);
d40b38b4	186	else
abf1d0b0 SH	187	snprintf(buf, len, "%.0fbit", tmp);
abf1d0b0 SH	188	} else {
8f7574ed ED	189	if (tmp >= 1000.0*1000000000.0)
	190	snprintf(buf, len, "%.0fGbit", tmp/1000000000.0);
	191	else if (tmp >= 1000.0*1000000.0)
abf1d0b0 SH	192	snprintf(buf, len, "%.0fMbit", tmp/1000000.0);
	193	else if (tmp >= 1000.0 * 1000.0)
	194	snprintf(buf, len, "%.0fKbit", tmp/1000.0);
d40b38b4	195	else
abf1d0b0	196	snprintf(buf, len, "%.0fbit", tmp);
d40b38b4	197	}
aba5acdf SH	198	}
aba5acdf SH	199
8f7574ed	200	char * sprint_rate(__u64 rate, char *buf)
aba5acdf	201	{
d40b38b4	202	print_rate(buf, SPRINT_BSIZE-1, rate);
aba5acdf SH	203	return buf;
	204	}
	205
8f34caaf	206	int get_time(unsigned time, const char str)
aba5acdf SH	207	{
	208	double t;
	209	char *p;
	210
	211	t = strtod(str, &p);
	212	if (p == str)
	213	return -1;
	214
	215	if (*p) {
	216	if (strcasecmp(p, "s") == 0 \|\| strcasecmp(p, "sec")==0 \|\|
	217	strcasecmp(p, "secs")==0)
f0bda7e5	218	t *= TIME_UNITS_PER_SEC;
aba5acdf SH	219	else if (strcasecmp(p, "ms") == 0 \|\| strcasecmp(p, "msec")==0 \|\|
aba5acdf SH	220	strcasecmp(p, "msecs") == 0)
f0bda7e5	221	t *= TIME_UNITS_PER_SEC/1000;
aba5acdf SH	222	else if (strcasecmp(p, "us") == 0 \|\| strcasecmp(p, "usec")==0 \|\|
aba5acdf SH	223	strcasecmp(p, "usecs") == 0)
f0bda7e5	224	t *= TIME_UNITS_PER_SEC/1000000;
aba5acdf SH	225	else
	226	return -1;
	227	}
	228
8f34caaf	229	*time = t;
aba5acdf SH	230	return 0;
	231	}
	232
	233
8f34caaf	234	void print_time(char *buf, int len, __u32 time)
aba5acdf	235	{
8f34caaf	236	double tmp = time;
aba5acdf	237
f0bda7e5 PM	238	if (tmp >= TIME_UNITS_PER_SEC)
	239	snprintf(buf, len, "%.1fs", tmp/TIME_UNITS_PER_SEC);
	240	else if (tmp >= TIME_UNITS_PER_SEC/1000)
	241	snprintf(buf, len, "%.1fms", tmp/(TIME_UNITS_PER_SEC/1000));
aba5acdf	242	else
89151447	243	snprintf(buf, len, "%uus", time);
aba5acdf SH	244	}
aba5acdf SH	245
8f34caaf	246	char * sprint_time(__u32 time, char *buf)
aba5acdf	247	{
8f34caaf	248	print_time(buf, SPRINT_BSIZE-1, time);
aba5acdf SH	249	return buf;
	250	}
	251
bd29e35d PM	252	char * sprint_ticks(__u32 ticks, char *buf)
	253	{
	254	return sprint_time(tc_core_tick2time(ticks), buf);
	255	}
	256
dbd90dc2	257	int get_size(unsigned size, const char str)
aba5acdf SH	258	{
	259	double sz;
	260	char *p;
	261
	262	sz = strtod(str, &p);
	263	if (p == str)
	264	return -1;
	265
	266	if (*p) {
	267	if (strcasecmp(p, "kb") == 0 \|\| strcasecmp(p, "k")==0)
	268	sz *= 1024;
dbd90dc2 SH	269	else if (strcasecmp(p, "gb") == 0 \|\| strcasecmp(p, "g")==0)
	270	sz = 10241024*1024;
	271	else if (strcasecmp(p, "gbit") == 0)
	272	sz = 10241024*1024/8;
aba5acdf SH	273	else if (strcasecmp(p, "mb") == 0 \|\| strcasecmp(p, "m")==0)
	274	sz = 10241024;
	275	else if (strcasecmp(p, "mbit") == 0)
	276	sz = 10241024/8;
	277	else if (strcasecmp(p, "kbit") == 0)
	278	sz *= 1024/8;
	279	else if (strcasecmp(p, "b") != 0)
	280	return -1;
	281	}
	282
	283	*size = sz;
	284	return 0;
	285	}
	286
	287	int get_size_and_cell(unsigned size, int cell_log, char *str)
	288	{
	289	char * slash = strchr(str, '/');
	290
	291	if (slash)
	292	*slash = 0;
	293
	294	if (get_size(size, str))
	295	return -1;
	296
	297	if (slash) {
	298	int cell;
	299	int i;
	300
	301	if (get_integer(&cell, slash+1, 0))
	302	return -1;
	303	*slash = '/';
	304
	305	for (i=0; i<32; i++) {
	306	if ((1<<i) == cell) {
	307	*cell_log = i;
	308	return 0;
	309	}
	310	}
	311	return -1;
	312	}
	313	return 0;
	314	}
	315
d40b38b4	316	void print_size(char *buf, int len, __u32 sz)
aba5acdf SH	317	{
	318	double tmp = sz;
	319
	320	if (sz >= 10241024 && fabs(10241024rint(tmp/(10241024)) - sz) < 1024)
	321	snprintf(buf, len, "%gMb", rint(tmp/(1024*1024)));
	322	else if (sz >= 1024 && fabs(1024*rint(tmp/1024) - sz) < 16)
	323	snprintf(buf, len, "%gKb", rint(tmp/1024));
	324	else
	325	snprintf(buf, len, "%ub", sz);
aba5acdf SH	326	}
	327
	328	char * sprint_size(__u32 size, char *buf)
	329	{
d40b38b4	330	print_size(buf, SPRINT_BSIZE-1, size);
aba5acdf SH	331	return buf;
	332	}
	333
d40b38b4	334	void print_qdisc_handle(char *buf, int len, __u32 h)
aba5acdf SH	335	{
aba5acdf SH	336	snprintf(buf, len, "%x:", TC_H_MAJ(h)>>16);
aba5acdf SH	337	}
	338
	339	char * sprint_qdisc_handle(__u32 h, char *buf)
	340	{
d40b38b4	341	print_qdisc_handle(buf, SPRINT_BSIZE-1, h);
aba5acdf SH	342	return buf;
	343	}
	344
2373fde9 SH	345	char * action_n2a(int action, char *buf, int len)
	346	{
	347	switch (action) {
	348	case -1:
	349	return "continue";
	350	break;
	351	case TC_ACT_OK:
	352	return "pass";
	353	break;
	354	case TC_ACT_SHOT:
	355	return "drop";
	356	break;
	357	case TC_ACT_RECLASSIFY:
	358	return "reclassify";
	359	case TC_ACT_PIPE:
	360	return "pipe";
	361	case TC_ACT_STOLEN:
	362	return "stolen";
	363	default:
	364	snprintf(buf, len, "%d", action);
	365	return buf;
	366	}
	367	}
aba5acdf	368
2373fde9 SH	369	int action_a2n(char arg, int result)
	370	{
	371	int res;
	372
	373	if (matches(arg, "continue") == 0)
	374	res = -1;
	375	else if (matches(arg, "drop") == 0)
	376	res = TC_ACT_SHOT;
	377	else if (matches(arg, "shot") == 0)
	378	res = TC_ACT_SHOT;
	379	else if (matches(arg, "pass") == 0)
	380	res = TC_ACT_OK;
	381	else if (strcmp(arg, "ok") == 0)
	382	res = TC_ACT_OK;
	383	else if (matches(arg, "reclassify") == 0)
	384	res = TC_ACT_RECLASSIFY;
	385	else {
	386	char dummy;
	387	if (sscanf(arg, "%d%c", &res, &dummy) != 1)
	388	return -1;
	389	}
	390	*result = res;
	391	return 0;
	392	}
	393
839c8456	394	int get_linklayer(unsigned val, const char arg)
292f29b4 JDB	395	{
	396	int res;
	397
	398	if (matches(arg, "ethernet") == 0)
	399	res = LINKLAYER_ETHERNET;
	400	else if (matches(arg, "atm") == 0)
	401	res = LINKLAYER_ATM;
	402	else if (matches(arg, "adsl") == 0)
	403	res = LINKLAYER_ATM;
	404	else
	405	return -1; /* Indicate error */
	406
	407	*val = res;
	408	return 0;
	409	}
	410
839c8456 JK	411	void print_linklayer(char *buf, int len, unsigned linklayer)
	412	{
	413	switch (linklayer) {
	414	case LINKLAYER_UNSPEC:
	415	snprintf(buf, len, "%s", "unspec");
	416	return;
	417	case LINKLAYER_ETHERNET:
	418	snprintf(buf, len, "%s", "ethernet");
	419	return;
	420	case LINKLAYER_ATM:
	421	snprintf(buf, len, "%s", "atm");
	422	return;
	423	default:
	424	snprintf(buf, len, "%s", "unknown");
	425	return;
	426	}
	427	}
	428
	429	char sprint_linklayer(unsigned linklayer, char buf)
	430	{
	431	print_linklayer(buf, SPRINT_BSIZE-1, linklayer);
	432	return buf;
	433	}
	434
6dc9f016	435	void print_tm(FILE * f, const struct tcf_t *tm)
2373fde9	436	{
5e8bc631	437	int hz = get_user_hz();
2373fde9	438	if (tm->install != 0)
63ae25d0	439	fprintf(f, " installed %u sec", (unsigned)(tm->install/hz));
2373fde9	440	if (tm->lastuse != 0)
63ae25d0	441	fprintf(f, " used %u sec", (unsigned)(tm->lastuse/hz));
2373fde9	442	if (tm->expires != 0)
63ae25d0	443	fprintf(f, " expires %u sec", (unsigned)(tm->expires/hz));
2373fde9	444	}
e5879dc6	445
	446	void print_tcstats2_attr(FILE fp, struct rtattr rta, char prefix, struct rtattr *xstats)
	447	{
	448	SPRINT_BUF(b1);
7d69fd97	449	struct rtattr *tbs[TCA_STATS_MAX + 1];
e5879dc6	450
7d69fd97	451	parse_rtattr_nested(tbs, TCA_STATS_MAX, rta);
e5879dc6	452
	453	if (tbs[TCA_STATS_BASIC]) {
	454	struct gnet_stats_basic bs = {0};
	455	memcpy(&bs, RTA_DATA(tbs[TCA_STATS_BASIC]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_BASIC]), sizeof(bs)));
	456	fprintf(fp, "%sSent %llu bytes %u pkt",
b906243b	457	prefix, (unsigned long long) bs.bytes, bs.packets);
e5879dc6	458	}
	459
	460	if (tbs[TCA_STATS_QUEUE]) {
	461	struct gnet_stats_queue q = {0};
	462	memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
	463	fprintf(fp, " (dropped %u, overlimits %u requeues %u) ",
	464	q.drops, q.overlimits, q.requeues);
	465	}
ae665a52	466
8f7574ed ED	467	if (tbs[TCA_STATS_RATE_EST64]) {
	468	struct gnet_stats_rate_est64 re = {0};
	469
	470	memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST64]),
	471	MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST64]),
	472	sizeof(re)));
	473	fprintf(fp, "\n%srate %s %llupps ",
	474	prefix, sprint_rate(re.bps, b1), re.pps);
	475	} else if (tbs[TCA_STATS_RATE_EST]) {
e5879dc6	476	struct gnet_stats_rate_est re = {0};
8f7574ed ED	477
	478	memcpy(&re, RTA_DATA(tbs[TCA_STATS_RATE_EST]),
	479	MIN(RTA_PAYLOAD(tbs[TCA_STATS_RATE_EST]), sizeof(re)));
e5879dc6	480	fprintf(fp, "\n%srate %s %upps ",
	481	prefix, sprint_rate(re.bps, b1), re.pps);
	482	}
	483
	484	if (tbs[TCA_STATS_QUEUE]) {
	485	struct gnet_stats_queue q = {0};
	486	memcpy(&q, RTA_DATA(tbs[TCA_STATS_QUEUE]), MIN(RTA_PAYLOAD(tbs[TCA_STATS_QUEUE]), sizeof(q)));
	487	if (!tbs[TCA_STATS_RATE_EST])
	488	fprintf(fp, "\n%s", prefix);
	489	fprintf(fp, "backlog %s %up requeues %u ",
	490	sprint_size(q.backlog, b1), q.qlen, q.requeues);
	491	}
	492
	493	if (xstats)
	494	*xstats = tbs[TCA_STATS_APP] ? : NULL;
	495	}
	496
	497	void print_tcstats_attr(FILE fp, struct rtattr tb[], char prefix, struct rtattr *xstats)
	498	{
	499	SPRINT_BUF(b1);
	500
	501	if (tb[TCA_STATS2]) {
	502	print_tcstats2_attr(fp, tb[TCA_STATS2], prefix, xstats);
	503	if (xstats && NULL == *xstats)
	504	goto compat_xstats;
	505	return;
	506	}
	507	/* backward compatibility */
	508	if (tb[TCA_STATS]) {
	509	struct tc_stats st;
	510
	511	/* handle case where kernel returns more/less than we know about */
	512	memset(&st, 0, sizeof(st));
	513	memcpy(&st, RTA_DATA(tb[TCA_STATS]), MIN(RTA_PAYLOAD(tb[TCA_STATS]), sizeof(st)));
	514
	515	fprintf(fp, "%sSent %llu bytes %u pkts (dropped %u, overlimits %u) ",
ae665a52	516	prefix, (unsigned long long)st.bytes, st.packets, st.drops,
e5879dc6	517	st.overlimits);
	518
	519	if (st.bps \|\| st.pps \|\| st.qlen \|\| st.backlog) {
	520	fprintf(fp, "\n%s", prefix);
	521	if (st.bps \|\| st.pps) {
	522	fprintf(fp, "rate ");
	523	if (st.bps)
	524	fprintf(fp, "%s ", sprint_rate(st.bps, b1));
	525	if (st.pps)
	526	fprintf(fp, "%upps ", st.pps);
	527	}
	528	if (st.qlen \|\| st.backlog) {
	529	fprintf(fp, "backlog ");
	530	if (st.backlog)
	531	fprintf(fp, "%s ", sprint_size(st.backlog, b1));
	532	if (st.qlen)
	533	fprintf(fp, "%up ", st.qlen);
	534	}
	535	}
	536	}
	537
	538	compat_xstats:
	539	if (tb[TCA_XSTATS] && xstats)
	540	*xstats = tb[TCA_XSTATS];
	541	}
	542