/*

 * utils.c

 *

 *		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 <math.h>

#include <unistd.h>

#include <fcntl.h>

#include <limits.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <string.h>

#include <ctype.h>

#include <netdb.h>

#include <arpa/inet.h>

#include <asm/types.h>

#include <linux/pkt_sched.h>

#include <linux/param.h>

#include <linux/if_arp.h>

#include <linux/mpls.h>

#include <linux/snmp.h>

#include <time.h>

#include <sys/time.h>

#include <errno.h>

#ifdef HAVE_LIBCAP

#include <sys/capability.h>

#endif

#include "rt_names.h"

#include "utils.h"

#include "ll_map.h"

#include "namespace.h"

int resolve_hosts;

int timestamp_short;

int pretty;

const char *_SL_ = "\n";

static int af_byte_len(int af);

static void print_time(char *buf, int len, __u32 time);

static void print_time64(char *buf, int len, __s64 time);

int read_prop(const char *dev, char *prop, long *value)

{

	char fname[128], buf[80], *endp, *nl;

	FILE *fp;

	long result;

	int ret;

	ret = snprintf(fname, sizeof(fname), "/sys/class/net/%s/%s",

			dev, prop);

	if (ret <= 0 || ret >= sizeof(fname)) {

		fprintf(stderr, "could not build pathname for property\n");

		return -1;

	}

	fp = fopen(fname, "r");

	if (fp == NULL) {

		fprintf(stderr, "fopen %s: %s\n", fname, strerror(errno));

		return -1;

	}

	if (!fgets(buf, sizeof(buf), fp)) {

		fprintf(stderr, "property \"%s\" in file %s is currently unknown\n", prop, fname);

		fclose(fp);

		goto out;

	}

	nl = strchr(buf, '\n');

	if (nl)

		*nl = '\0';

	fclose(fp);

	result = strtol(buf, &endp, 0);

	if (*endp || buf == endp) {

		fprintf(stderr, "value \"%s\" in file %s is not a number\n",

			buf, fname);

		goto out;

	}

	if ((result == LONG_MAX || result == LONG_MIN) && errno == ERANGE) {

		fprintf(stderr, "strtol %s: %s", fname, strerror(errno));

		goto out;

	}

	*value = result;

	return 0;

out:

	fprintf(stderr, "Failed to parse %s\n", fname);

	return -1;

}

int get_hex(char c)

{

	if (c >= 'A' && c <= 'F')

		return c - 'A' + 10;

	if (c >= 'a' && c <= 'f')

		return c - 'a' + 10;

	if (c >= '0' && c <= '9')

		return c - '0';

	return -1;

}

int get_integer(int *val, const char *arg, int base)

{

	long res;

	char *ptr;

	if (!arg || !*arg)

		return -1;

	res = strtol(arg, &ptr, base);

	/* If there were no digits at all, strtol()  stores

	 * the original value of nptr in *endptr (and returns 0).

	 * In particular, if *nptr is not '\0' but **endptr is '\0' on return,

	 * the entire string is valid.

	 */

	if (!ptr || ptr == arg || *ptr)

		return -1;

	/* If an underflow occurs, strtol() returns LONG_MIN.

	 * If an overflow occurs,  strtol() returns LONG_MAX.

	 * In both cases, errno is set to ERANGE.

	 */

	if ((res == LONG_MAX || res == LONG_MIN) && errno == ERANGE)

		return -1;

	/* Outside range of int */

	if (res < INT_MIN || res > INT_MAX)

		return -1;

	*val = res;

	return 0;

}

int mask2bits(__u32 netmask)

{

	unsigned int bits = 0;

	__u32 mask = ntohl(netmask);

	__u32 host = ~mask;

	/* a valid netmask must be 2^n - 1 */

	if ((host & (host + 1)) != 0)

		return -1;

	for (; mask; mask <<= 1)

		++bits;

	return bits;

}

static int get_netmask(unsigned int *val, const char *arg, int base)

{

	inet_prefix addr;

	if (!get_unsigned(val, arg, base))

		return 0;

	/* try converting dotted quad to CIDR */

	if (!get_addr_1(&addr, arg, AF_INET) && addr.family == AF_INET) {

		int b = mask2bits(addr.data[0]);

		if (b >= 0) {

			*val = b;

			return 0;

		}

	}

	return -1;

}

int get_unsigned(unsigned int *val, const char *arg, int base)

{

	unsigned long res;

	char *ptr;

	if (!arg || !*arg)

		return -1;

	res = strtoul(arg, &ptr, base);

	/* empty string or trailing non-digits */

	if (!ptr || ptr == arg || *ptr)

		return -1;

	/* overflow */

	if (res == ULONG_MAX && errno == ERANGE)

		return -1;

	/* out side range of unsigned */

	if (res > UINT_MAX)

		return -1;

	*val = res;

	return 0;

}

/*

 * get_time_rtt is "translated" from a similar routine "get_time" in

 * tc_util.c.  We don't use the exact same routine because tc passes

 * microseconds to the kernel and the callers of get_time_rtt want to

 * pass milliseconds (standard unit for rtt values since 2.6.27), and

 * have a different assumption for the units of a "raw" number.

 */

int get_time_rtt(unsigned int *val, const char *arg, int *raw)

{

	double t;

	unsigned long res;

	char *p;

	if (strchr(arg, '.') != NULL) {

		t = strtod(arg, &p);

		if (t < 0.0)

			return -1;

		/* no digits? */

		if (!p || p == arg)

			return -1;

		/* over/underflow */

		if ((t == HUGE_VALF || t == HUGE_VALL) && errno == ERANGE)

			return -1;

	} else {

		res = strtoul(arg, &p, 0);

		/* empty string? */

		if (!p || p == arg)

			return -1;

		/* overflow */

		if (res == ULONG_MAX && errno == ERANGE)

			return -1;

		t = (double)res;

	}

	if (p == arg)

		return -1;

	*raw = 1;

	if (*p) {

		*raw = 0;

		if (strcasecmp(p, "s") == 0 ||

		    strcasecmp(p, "sec") == 0 ||

		    strcasecmp(p, "secs") == 0)

			t *= 1000;

		else if (strcasecmp(p, "ms") == 0 ||

			 strcasecmp(p, "msec") == 0 ||

			 strcasecmp(p, "msecs") == 0)

			t *= 1.0; /* allow suffix, do nothing */

		else

			return -1;

	}

	/* emulate ceil() without having to bring-in -lm and always be >= 1 */

	*val = t;

	if (*val < t)

		*val += 1;

	return 0;

}

int get_u64(__u64 *val, const char *arg, int base)

{

	unsigned long long res;

	char *ptr;

	if (!arg || !*arg)

		return -1;

	res = strtoull(arg, &ptr, base);

	/* empty string or trailing non-digits */

	if (!ptr || ptr == arg || *ptr)

		return -1;

	/* overflow */

	if (res == ULLONG_MAX && errno == ERANGE)

		return -1;

	/* in case ULL is 128 bits */

	if (res > 0xFFFFFFFFFFFFFFFFULL)

		return -1;

	*val = res;

	return 0;

}

int get_u32(__u32 *val, const char *arg, int base)

{

	unsigned long res;

	char *ptr;

	if (!arg || !*arg)

		return -1;

	res = strtoul(arg, &ptr, base);

	/* empty string or trailing non-digits */

	if (!ptr || ptr == arg || *ptr)

		return -1;

	/* overflow */

	if (res == ULONG_MAX && errno == ERANGE)

		return -1;

	/* in case UL > 32 bits */

	if (res > 0xFFFFFFFFUL)

		return -1;

	*val = res;

	return 0;

}

int get_u16(__u16 *val, const char *arg, int base)

{

	unsigned long res;

	char *ptr;

	if (!arg || !*arg)

		return -1;

	res = strtoul(arg, &ptr, base);

	/* empty string or trailing non-digits */

	if (!ptr || ptr == arg || *ptr)

		return -1;

	/* overflow */

	if (res == ULONG_MAX && errno == ERANGE)

		return -1;

	if (res > 0xFFFFUL)

		return -1;

	*val = res;

	return 0;

}

int get_u8(__u8 *val, const char *arg, int base)

{

	unsigned long res;

	char *ptr;

	if (!arg || !*arg)

		return -1;

	res = strtoul(arg, &ptr, base);

	/* empty string or trailing non-digits */

	if (!ptr || ptr == arg || *ptr)

		return -1;

	/* overflow */

	if (res == ULONG_MAX && errno == ERANGE)

		return -1;

	if (res > 0xFFUL)

		return -1;

	*val = res;

	return 0;

}

int get_s64(__s64 *val, const char *arg, int base)

{

	long long res;

	char *ptr;

	errno = 0;

	if (!arg || !*arg)

		return -1;

	res = strtoll(arg, &ptr, base);

	if (!ptr || ptr == arg || *ptr)

		return -1;

	if ((res == LLONG_MIN || res == LLONG_MAX) && errno == ERANGE)

		return -1;

	if (res > INT64_MAX || res < INT64_MIN)

		return -1;

	*val = res;

	return 0;

}

int get_s32(__s32 *val, const char *arg, int base)

{

	long res;

	char *ptr;

	errno = 0;

	if (!arg || !*arg)

		return -1;

	res = strtol(arg, &ptr, base);

	if (!ptr || ptr == arg || *ptr)

		return -1;

	if ((res == LONG_MIN || res == LONG_MAX) && errno == ERANGE)

		return -1;

	if (res > INT32_MAX || res < INT32_MIN)

		return -1;

	*val = res;

	return 0;

}

int get_be64(__be64 *val, const char *arg, int base)

{

	__u64 v;

	int ret = get_u64(&v, arg, base);

	if (!ret)

		*val = htonll(v);

	return ret;

}

int get_be32(__be32 *val, const char *arg, int base)

{

	__u32 v;

	int ret = get_u32(&v, arg, base);

	if (!ret)

		*val = htonl(v);

	return ret;

}

int get_be16(__be16 *val, const char *arg, int base)

{

	__u16 v;

	int ret = get_u16(&v, arg, base);

	if (!ret)

		*val = htons(v);

	return ret;

}

/* This uses a non-standard parsing (ie not inet_aton, or inet_pton)

 * because of legacy choice to parse 10.8 as 10.8.0.0 not 10.0.0.8

 */

static int get_addr_ipv4(__u8 *ap, const char *cp)

{

	int i;

	for (i = 0; i < 4; i++) {

		unsigned long n;

		char *endp;

		n = strtoul(cp, &endp, 0);

		if (n > 255)

			return -1;	/* bogus network value */

		if (endp == cp) /* no digits */

			return -1;

		ap[i] = n;

		if (*endp == '\0')

			break;

		if (i == 3 || *endp != '.')

			return -1;	/* extra characters */

		cp = endp + 1;

	}

	return 1;

}

int get_addr64(__u64 *ap, const char *cp)

{

	int i;

	union {

		__u16 v16[4];

		__u64 v64;

	} val;

	for (i = 0; i < 4; i++) {

		unsigned long n;

		char *endp;

		n = strtoul(cp, &endp, 16);

		if (n > 0xffff)

			return -1;	/* bogus network value */

		if (endp == cp) /* no digits */

			return -1;

		val.v16[i] = htons(n);

		if (*endp == '\0')

			break;

		if (i == 3 || *endp != ':')

			return -1;	/* extra characters */

		cp = endp + 1;

	}

	*ap = val.v64;

	return 1;

}

static void set_address_type(inet_prefix *addr)

{

	switch (addr->family) {

	case AF_INET:

		if (!addr->data[0])

			addr->flags |= ADDRTYPE_INET_UNSPEC;

		else if (IN_MULTICAST(ntohl(addr->data[0])))

			addr->flags |= ADDRTYPE_INET_MULTI;

		else

			addr->flags |= ADDRTYPE_INET;

		break;

	case AF_INET6:

		if (IN6_IS_ADDR_UNSPECIFIED(addr->data))

			addr->flags |= ADDRTYPE_INET_UNSPEC;

		else if (IN6_IS_ADDR_MULTICAST(addr->data))

			addr->flags |= ADDRTYPE_INET_MULTI;

		else

			addr->flags |= ADDRTYPE_INET;

		break;

	}

}

static int __get_addr_1(inet_prefix *addr, const char *name, int family)

{

	memset(addr, 0, sizeof(*addr));

	if (strcmp(name, "default") == 0) {

		if ((family == AF_DECnet) || (family == AF_MPLS))

			return -1;

		addr->family = family;

		addr->bytelen = af_byte_len(addr->family);

		addr->bitlen = -2;

		addr->flags |= PREFIXLEN_SPECIFIED;

		return 0;

	}

	if (strcmp(name, "all") == 0 ||

	    strcmp(name, "any") == 0) {

		if ((family == AF_DECnet) || (family == AF_MPLS))

			return -1;

		addr->family = family;

		addr->bytelen = 0;

		addr->bitlen = -2;

		return 0;

	}

	if (family == AF_PACKET) {

		int len;

		len = ll_addr_a2n((char *) &addr->data, sizeof(addr->data),

				  name);

		if (len < 0)

			return -1;

		addr->family = AF_PACKET;

		addr->bytelen = len;

		addr->bitlen = len * 8;

		return 0;

	}

	if (strchr(name, ':')) {

		addr->family = AF_INET6;

		if (family != AF_UNSPEC && family != AF_INET6)

			return -1;

		if (inet_pton(AF_INET6, name, addr->data) <= 0)

			return -1;

		addr->bytelen = 16;

		addr->bitlen = -1;

		return 0;

	}

	if (family == AF_MPLS) {

		unsigned int maxlabels;

		int i;

		addr->family = AF_MPLS;

		if (mpls_pton(AF_MPLS, name, addr->data,

			      sizeof(addr->data)) <= 0)

			return -1;

		addr->bytelen = 4;

		addr->bitlen = 20;

		/* How many bytes do I need? */

		maxlabels = sizeof(addr->data) / sizeof(struct mpls_label);

		for (i = 0; i < maxlabels; i++) {

			if (ntohl(addr->data[i]) & MPLS_LS_S_MASK) {

				addr->bytelen = (i + 1)*4;

				break;

			}

		}

		return 0;

	}

	addr->family = AF_INET;

	if (family != AF_UNSPEC && family != AF_INET)

		return -1;

	if (get_addr_ipv4((__u8 *)addr->data, name) <= 0)

		return -1;

	addr->bytelen = 4;

	addr->bitlen = -1;

	return 0;

}

int get_addr_1(inet_prefix *addr, const char *name, int family)

{

	int ret;

	ret = __get_addr_1(addr, name, family);

	if (ret)

		return ret;

	set_address_type(addr);

	return 0;

}

int af_bit_len(int af)

{

	switch (af) {

	case AF_INET6:

		return 128;

	case AF_INET:

		return 32;

	case AF_DECnet:

		return 16;

	case AF_IPX:

		return 80;

	case AF_MPLS:

		return 20;

	}

	return 0;

}

static int af_byte_len(int af)

{

	return af_bit_len(af) / 8;

}

int get_prefix_1(inet_prefix *dst, char *arg, int family)

{

	char *slash;

	int err, bitlen, flags;

	slash = strchr(arg, '/');

	if (slash)

		*slash = 0;

	err = get_addr_1(dst, arg, family);

	if (slash)

		*slash = '/';

	if (err)

		return err;

	bitlen = af_bit_len(dst->family);

	flags = 0;

	if (slash) {

		unsigned int plen;

		if (dst->bitlen == -2)

			return -1;

		if (get_netmask(&plen, slash + 1, 0))

			return -1;

		if (plen > bitlen)

			return -1;

		flags |= PREFIXLEN_SPECIFIED;

		bitlen = plen;

	} else {

		if (dst->bitlen == -2)

			bitlen = 0;

	}

	dst->flags |= flags;

	dst->bitlen = bitlen;

	return 0;

}

static const char *family_name_verbose(int family)

{

	if (family == AF_UNSPEC)

		return "any valid";

	return family_name(family);

}

int get_addr(inet_prefix *dst, const char *arg, int family)

{

	if (get_addr_1(dst, arg, family)) {

		fprintf(stderr,

			"Error: %s address is expected rather than \"%s\".\n",

			family_name_verbose(family), arg);

		exit(1);

	}

	return 0;

}

int get_addr_rta(inet_prefix *dst, const struct rtattr *rta, int family)

{

	const int len = RTA_PAYLOAD(rta);

	const void *data = RTA_DATA(rta);

	switch (len) {

	case 4:

		dst->family = AF_INET;

		dst->bytelen = 4;

		memcpy(dst->data, data, 4);

		break;

	case 16:

		dst->family = AF_INET6;

		dst->bytelen = 16;

		memcpy(dst->data, data, 16);

		break;

	case 2:

		dst->family = AF_DECnet;

		dst->bytelen = 2;

		memcpy(dst->data, data, 2);

		break;

	case 10:

		dst->family = AF_IPX;

		dst->bytelen = 10;

		memcpy(dst->data, data, 10);

		break;

	default:

		return -1;

	}

	if (family != AF_UNSPEC && family != dst->family)

		return -2;

	dst->bitlen = -1;

	dst->flags = 0;

	set_address_type(dst);

	return 0;

}

int get_prefix(inet_prefix *dst, char *arg, int family)

{

	if (family == AF_PACKET) {

		fprintf(stderr,

			"Error: \"%s\" may be inet prefix, but it is not allowed in this context.\n",

			arg);

		exit(1);

	}

	if (get_prefix_1(dst, arg, family)) {

		fprintf(stderr,

			"Error: %s prefix is expected rather than \"%s\".\n",

			family_name_verbose(family), arg);

		exit(1);

	}

	return 0;

}

__u32 get_addr32(const char *name)

{

	inet_prefix addr;

	if (get_addr_1(&addr, name, AF_INET)) {

		fprintf(stderr,

			"Error: an IP address is expected rather than \"%s\"\n",

			name);

		exit(1);

	}

	return addr.data[0];

}

void incomplete_command(void)

{

	fprintf(stderr, "Command line is not complete. Try option \"help\"\n");

	exit(-1);

}

void missarg(const char *key)

{

	fprintf(stderr, "Error: argument \"%s\" is required\n", key);

	exit(-1);

}

void invarg(const char *msg, const char *arg)

{

	fprintf(stderr, "Error: argument \"%s\" is wrong: %s\n", arg, msg);

	exit(-1);

}

void duparg(const char *key, const char *arg)

{

	fprintf(stderr,

		"Error: duplicate \"%s\": \"%s\" is the second value.\n",

		key, arg);

	exit(-1);

}

void duparg2(const char *key, const char *arg)

{

	fprintf(stderr,

		"Error: either \"%s\" is duplicate, or \"%s\" is a garbage.\n",

		key, arg);

	exit(-1);

}

int nodev(const char *dev)

{

	fprintf(stderr, "Cannot find device \"%s\"\n", dev);

	return -1;

}

int check_ifname(const char *name)

{

	/* These checks mimic kernel checks in dev_valid_name */

	if (*name == '\0')

		return -1;

	if (strlen(name) >= IFNAMSIZ)

		return -1;

	while (*name) {

		if (*name == '/' || isspace(*name))

			return -1;

		++name;

	}

	return 0;

}

/* buf is assumed to be IFNAMSIZ */

int get_ifname(char *buf, const char *name)

{

	int ret;

	ret = check_ifname(name);

	if (ret == 0)

		strncpy(buf, name, IFNAMSIZ);

	return ret;

}

const char *get_ifname_rta(int ifindex, const struct rtattr *rta)

{

	const char *name;

	if (rta) {

		name = rta_getattr_str(rta);

	} else {

		fprintf(stderr,

			"BUG: device with ifindex %d has nil ifname\n",

			ifindex);

		name = ll_idx_n2a(ifindex);

	}

	if (check_ifname(name))

		return NULL;

	return name;

}

/* Returns false if 'prefix' is a not empty prefix of 'string'.

 */

bool matches(const char *prefix, const char *string)

{

	if (!*prefix)

		return true;

	while (*string && *prefix == *string) {