/*

 * ipaddress.c		"ip address".

 *

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

#include <fcntl.h>

#include <sys/ioctl.h>

#include <sys/socket.h>

#include <sys/param.h>

#include <errno.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <string.h>

#include <fnmatch.h>

#include <linux/netdevice.h>

#include <linux/if_arp.h>

#include <linux/if_infiniband.h>

#include <linux/sockios.h>

#include <linux/net_namespace.h>

#include "rt_names.h"

#include "utils.h"

#include "ll_map.h"

#include "ip_common.h"

#include "color.h"

enum {

	IPADD_LIST,

	IPADD_FLUSH,

	IPADD_SAVE,

};

static struct link_filter filter;

static int do_link;

static void usage(void) __attribute__((noreturn));

static void usage(void)

{

	if (do_link)

		iplink_usage();

	fprintf(stderr,

		"Usage: ip address {add|change|replace} IFADDR dev IFNAME [ LIFETIME ]\n"

		"                                                      [ CONFFLAG-LIST ]\n"

		"       ip address del IFADDR dev IFNAME [mngtmpaddr]\n"

		"       ip address {save|flush} [ dev IFNAME ] [ scope SCOPE-ID ]\n"

		"                            [ to PREFIX ] [ FLAG-LIST ] [ label LABEL ] [up]\n"

		"       ip address [ show [ dev IFNAME ] [ scope SCOPE-ID ] [ master DEVICE ]\n"

		"                         [ type TYPE ] [ to PREFIX ] [ FLAG-LIST ]\n"

		"                         [ label LABEL ] [up] [ vrf NAME ] ]\n"

		"       ip address {showdump|restore}\n"

		"IFADDR := PREFIX | ADDR peer PREFIX\n"

		"          [ broadcast ADDR ] [ anycast ADDR ]\n"

		"          [ label IFNAME ] [ scope SCOPE-ID ] [ metric METRIC ]\n"

		"SCOPE-ID := [ host | link | global | NUMBER ]\n"

		"FLAG-LIST := [ FLAG-LIST ] FLAG\n"

		"FLAG  := [ permanent | dynamic | secondary | primary |\n"

		"           [-]tentative | [-]deprecated | [-]dadfailed | temporary |\n"

		"           CONFFLAG-LIST ]\n"

		"CONFFLAG-LIST := [ CONFFLAG-LIST ] CONFFLAG\n"

		"CONFFLAG  := [ home | nodad | mngtmpaddr | noprefixroute | autojoin ]\n"

		"LIFETIME := [ valid_lft LFT ] [ preferred_lft LFT ]\n"

		"LFT := forever | SECONDS\n"

		"TYPE := { vlan | veth | vcan | vxcan | dummy | ifb | macvlan | macvtap |\n"

		"          bridge | bond | ipoib | ip6tnl | ipip | sit | vxlan | lowpan |\n"

		"          gre | gretap | erspan | ip6gre | ip6gretap | ip6erspan | vti |\n"

		"          nlmon | can | bond_slave | ipvlan | geneve | bridge_slave |\n"

		"          hsr | macsec | netdevsim }\n");

	exit(-1);

}

static void print_link_flags(FILE *fp, unsigned int flags, unsigned int mdown)

{

	open_json_array(PRINT_ANY, is_json_context() ? "flags" : "<");

	if (flags & IFF_UP && !(flags & IFF_RUNNING))

		print_string(PRINT_ANY, NULL,

			     flags ? "%s," : "%s", "NO-CARRIER");

	flags &= ~IFF_RUNNING;

#define _PF(f) if (flags&IFF_##f) {					\

		flags &= ~IFF_##f ;					\

		print_string(PRINT_ANY, NULL, flags ? "%s," : "%s", #f); }

	_PF(LOOPBACK);

	_PF(BROADCAST);

	_PF(POINTOPOINT);

	_PF(MULTICAST);

	_PF(NOARP);

	_PF(ALLMULTI);

	_PF(PROMISC);

	_PF(MASTER);

	_PF(SLAVE);

	_PF(DEBUG);

	_PF(DYNAMIC);

	_PF(AUTOMEDIA);

	_PF(PORTSEL);

	_PF(NOTRAILERS);

	_PF(UP);

	_PF(LOWER_UP);

	_PF(DORMANT);

	_PF(ECHO);

#undef _PF

	if (flags)

		print_hex(PRINT_ANY, NULL, "%x", flags);

	if (mdown)

		print_string(PRINT_ANY, NULL, ",%s", "M-DOWN");

	close_json_array(PRINT_ANY, "> ");

}

static const char *oper_states[] = {

	"UNKNOWN", "NOTPRESENT", "DOWN", "LOWERLAYERDOWN",

	"TESTING", "DORMANT",	 "UP"

};

static void print_operstate(FILE *f, __u8 state)

{

	if (state >= ARRAY_SIZE(oper_states)) {

		if (is_json_context())

			print_uint(PRINT_JSON, "operstate_index", NULL, state);

		else

			print_0xhex(PRINT_FP, NULL, "state %#llx", state);

	} else if (brief) {

		print_color_string(PRINT_ANY,

				   oper_state_color(state),

				   "operstate",

				   "%-14s ",

				   oper_states[state]);

	} else {

		if (is_json_context())

			print_string(PRINT_JSON,

				     "operstate",

				     NULL, oper_states[state]);

		else {

			fprintf(f, "state ");

			color_fprintf(f, oper_state_color(state),

				      "%s ", oper_states[state]);

		}

	}

}

int get_operstate(const char *name)

{

	int i;

	for (i = 0; i < ARRAY_SIZE(oper_states); i++)

		if (strcasecmp(name, oper_states[i]) == 0)

			return i;

	return -1;

}

static void print_queuelen(FILE *f, struct rtattr *tb[IFLA_MAX + 1])

{

	int qlen;

	if (tb[IFLA_TXQLEN])

		qlen = rta_getattr_u32(tb[IFLA_TXQLEN]);

	else {

		struct ifreq ifr = {};

		int s = socket(AF_INET, SOCK_STREAM, 0);

		if (s < 0)

			return;

		strcpy(ifr.ifr_name, rta_getattr_str(tb[IFLA_IFNAME]));

		if (ioctl(s, SIOCGIFTXQLEN, &ifr) < 0) {

			fprintf(stderr,

				"ioctl(SIOCGIFTXQLEN) failed: %s\n",

				strerror(errno));

			close(s);

			return;

		}

		close(s);

		qlen = ifr.ifr_qlen;

	}

	if (qlen)

		print_int(PRINT_ANY, "txqlen", "qlen %d", qlen);

}

static const char *link_modes[] = {

	"DEFAULT", "DORMANT"

};

static void print_linkmode(FILE *f, struct rtattr *tb)

{

	unsigned int mode = rta_getattr_u8(tb);

	if (mode >= ARRAY_SIZE(link_modes))

		print_int(PRINT_ANY,

			  "linkmode_index",

			  "mode %d ",

			  mode);

	else

		print_string(PRINT_ANY,

			     "linkmode",

			     "mode %s "

			     , link_modes[mode]);

}

static char *parse_link_kind(struct rtattr *tb, bool slave)

{

	struct rtattr *linkinfo[IFLA_INFO_MAX+1];

	int attr = slave ? IFLA_INFO_SLAVE_KIND : IFLA_INFO_KIND;

	parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb);

	if (linkinfo[attr])

		return RTA_DATA(linkinfo[attr]);

	return "";

}

static int match_link_kind(struct rtattr **tb, const char *kind, bool slave)

{

	if (!tb[IFLA_LINKINFO])

		return -1;

	return strcmp(parse_link_kind(tb[IFLA_LINKINFO], slave), kind);

}

static void print_linktype(FILE *fp, struct rtattr *tb)

{

	struct rtattr *linkinfo[IFLA_INFO_MAX+1];

	struct link_util *lu;

	struct link_util *slave_lu;

	char slave[32];

	parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb);

	open_json_object("linkinfo");

	if (linkinfo[IFLA_INFO_KIND]) {

		const char *kind

			= rta_getattr_str(linkinfo[IFLA_INFO_KIND]);

		print_nl();

		print_string(PRINT_ANY, "info_kind", "    %s ", kind);

		lu = get_link_kind(kind);

		if (lu && lu->print_opt) {

			struct rtattr *attr[lu->maxattr+1], **data = NULL;

			if (linkinfo[IFLA_INFO_DATA]) {

				parse_rtattr_nested(attr, lu->maxattr,

						    linkinfo[IFLA_INFO_DATA]);

				data = attr;

			}

			open_json_object("info_data");

			lu->print_opt(lu, fp, data);

			close_json_object();

			if (linkinfo[IFLA_INFO_XSTATS] && show_stats &&

			    lu->print_xstats) {

				open_json_object("info_xstats");

				lu->print_xstats(lu, fp, linkinfo[IFLA_INFO_XSTATS]);

				close_json_object();

			}

		}

	}

	if (linkinfo[IFLA_INFO_SLAVE_KIND]) {

		const char *slave_kind

			= rta_getattr_str(linkinfo[IFLA_INFO_SLAVE_KIND]);

		print_nl();

		print_string(PRINT_ANY,

			     "info_slave_kind",

			     "    %s_slave ",

			     slave_kind);

		snprintf(slave, sizeof(slave), "%s_slave", slave_kind);

		slave_lu = get_link_kind(slave);

		if (slave_lu && slave_lu->print_opt) {

			struct rtattr *attr[slave_lu->maxattr+1], **data = NULL;

			if (linkinfo[IFLA_INFO_SLAVE_DATA]) {

				parse_rtattr_nested(attr, slave_lu->maxattr,

						    linkinfo[IFLA_INFO_SLAVE_DATA]);

				data = attr;

			}

			open_json_object("info_slave_data");

			slave_lu->print_opt(slave_lu, fp, data);

			close_json_object();

		}

	}

	close_json_object();

}

static void print_af_spec(FILE *fp, struct rtattr *af_spec_attr)

{

	struct rtattr *inet6_attr;

	struct rtattr *tb[IFLA_INET6_MAX + 1];

	inet6_attr = parse_rtattr_one_nested(AF_INET6, af_spec_attr);

	if (!inet6_attr)

		return;

	parse_rtattr_nested(tb, IFLA_INET6_MAX, inet6_attr);

	if (tb[IFLA_INET6_ADDR_GEN_MODE]) {

		__u8 mode = rta_getattr_u8(tb[IFLA_INET6_ADDR_GEN_MODE]);

		SPRINT_BUF(b1);

		switch (mode) {

		case IN6_ADDR_GEN_MODE_EUI64:

			print_string(PRINT_ANY,

				     "inet6_addr_gen_mode",

				     "addrgenmode %s ",

				     "eui64");

			break;

		case IN6_ADDR_GEN_MODE_NONE:

			print_string(PRINT_ANY,

				     "inet6_addr_gen_mode",

				     "addrgenmode %s ",

				     "none");

			break;

		case IN6_ADDR_GEN_MODE_STABLE_PRIVACY:

			print_string(PRINT_ANY,

				     "inet6_addr_gen_mode",

				     "addrgenmode %s ",

				     "stable_secret");

			break;

		case IN6_ADDR_GEN_MODE_RANDOM:

			print_string(PRINT_ANY,

				     "inet6_addr_gen_mode",

				     "addrgenmode %s ",

				     "random");

			break;

		default:

			snprintf(b1, sizeof(b1), "%#.2hhx", mode);

			print_string(PRINT_ANY,

				     "inet6_addr_gen_mode",

				     "addrgenmode %s ",

				     b1);

			break;

		}

	}

}

static void print_vf_stats64(FILE *fp, struct rtattr *vfstats);

static void print_vfinfo(FILE *fp, struct ifinfomsg *ifi, struct rtattr *vfinfo)

{

	struct ifla_vf_mac *vf_mac;

	struct ifla_vf_broadcast *vf_broadcast;

	struct ifla_vf_tx_rate *vf_tx_rate;

	struct rtattr *vf[IFLA_VF_MAX + 1] = {};

	SPRINT_BUF(b1);

	if (vfinfo->rta_type != IFLA_VF_INFO) {

		fprintf(stderr, "BUG: rta type is %d\n", vfinfo->rta_type);

		return;

	}

	parse_rtattr_nested(vf, IFLA_VF_MAX, vfinfo);

	vf_mac = RTA_DATA(vf[IFLA_VF_MAC]);

	vf_broadcast = RTA_DATA(vf[IFLA_VF_BROADCAST]);

	vf_tx_rate = RTA_DATA(vf[IFLA_VF_TX_RATE]);

	print_string(PRINT_FP, NULL, "%s    ", _SL_);

	print_int(PRINT_ANY, "vf", "vf %d ", vf_mac->vf);

	print_string(PRINT_ANY,

		     "link_type",

		     "    link/%s ",

		     ll_type_n2a(ifi->ifi_type, b1, sizeof(b1)));

	print_color_string(PRINT_ANY, COLOR_MAC,

			   "address", "%s",

			   ll_addr_n2a((unsigned char *) &vf_mac->mac,

				       ifi->ifi_type == ARPHRD_ETHER ?

				       ETH_ALEN : INFINIBAND_ALEN,

				       ifi->ifi_type,

				       b1, sizeof(b1)));

	if (vf[IFLA_VF_BROADCAST]) {

		if (ifi->ifi_flags&IFF_POINTOPOINT) {

			print_string(PRINT_FP, NULL, " peer ", NULL);

			print_bool(PRINT_JSON,

				   "link_pointtopoint", NULL, true);

		} else

			print_string(PRINT_FP, NULL, " brd ", NULL);

		print_color_string(PRINT_ANY, COLOR_MAC,

				   "broadcast", "%s",

				   ll_addr_n2a((unsigned char *) &vf_broadcast->broadcast,

					       ifi->ifi_type == ARPHRD_ETHER ?

					       ETH_ALEN : INFINIBAND_ALEN,

					       ifi->ifi_type,

					       b1, sizeof(b1)));

	}

	if (vf[IFLA_VF_VLAN_LIST]) {

		struct rtattr *i, *vfvlanlist = vf[IFLA_VF_VLAN_LIST];

		int rem = RTA_PAYLOAD(vfvlanlist);

		open_json_array(PRINT_JSON, "vlan_list");

		for (i = RTA_DATA(vfvlanlist);

		     RTA_OK(i, rem); i = RTA_NEXT(i, rem)) {

			struct ifla_vf_vlan_info *vf_vlan_info = RTA_DATA(i);

			SPRINT_BUF(b2);

			open_json_object(NULL);

			if (vf_vlan_info->vlan)

				print_int(PRINT_ANY,

					  "vlan",

					  ", vlan %d",

					  vf_vlan_info->vlan);

			if (vf_vlan_info->qos)

				print_int(PRINT_ANY,

					  "qos",

					  ", qos %d",

					  vf_vlan_info->qos);

			if (vf_vlan_info->vlan_proto &&

			    vf_vlan_info->vlan_proto != htons(ETH_P_8021Q))

				print_string(PRINT_ANY,

					     "protocol",

					     ", vlan protocol %s",

					     ll_proto_n2a(

						     vf_vlan_info->vlan_proto,

						     b2, sizeof(b2)));

			close_json_object();

		}

		close_json_array(PRINT_JSON, NULL);

	} else {

		struct ifla_vf_vlan *vf_vlan = RTA_DATA(vf[IFLA_VF_VLAN]);

		if (vf_vlan->vlan)

			print_int(PRINT_ANY,

				  "vlan",

				  ", vlan %d",

				  vf_vlan->vlan);

		if (vf_vlan->qos)

			print_int(PRINT_ANY, "qos", ", qos %d", vf_vlan->qos);

	}

	if (vf_tx_rate->rate)

		print_uint(PRINT_ANY,

			   "tx_rate",

			   ", tx rate %u (Mbps)",

			   vf_tx_rate->rate);

	if (vf[IFLA_VF_RATE]) {

		struct ifla_vf_rate *vf_rate = RTA_DATA(vf[IFLA_VF_RATE]);

		int max_tx = vf_rate->max_tx_rate;

		int min_tx = vf_rate->min_tx_rate;

		if (is_json_context()) {

			open_json_object("rate");

			print_uint(PRINT_JSON, "max_tx", NULL, max_tx);

			print_uint(PRINT_ANY, "min_tx", NULL, min_tx);

			close_json_object();

		} else {

			if (max_tx)

				fprintf(fp, ", max_tx_rate %uMbps", max_tx);

			if (min_tx)

				fprintf(fp, ", min_tx_rate %uMbps", min_tx);

		}

	}

	if (vf[IFLA_VF_SPOOFCHK]) {

		struct ifla_vf_spoofchk *vf_spoofchk =

			RTA_DATA(vf[IFLA_VF_SPOOFCHK]);

		if (vf_spoofchk->setting != -1)

			print_bool(PRINT_ANY,

				   "spoofchk",

				   vf_spoofchk->setting ?

				   ", spoof checking on" : ", spoof checking off",

				   vf_spoofchk->setting);

	}

	if (vf[IFLA_VF_IB_NODE_GUID]) {

		struct ifla_vf_guid *guid = RTA_DATA(vf[IFLA_VF_IB_NODE_GUID]);

		uint64_t node_guid = ntohll(guid->guid);

		print_string(PRINT_ANY, "node guid", ", NODE_GUID %s",

			     ll_addr_n2a((const unsigned char *)&node_guid,

					 sizeof(node_guid), ARPHRD_INFINIBAND,

					 b1, sizeof(b1)));

	}

	if (vf[IFLA_VF_IB_PORT_GUID]) {

		struct ifla_vf_guid *guid = RTA_DATA(vf[IFLA_VF_IB_PORT_GUID]);

		uint64_t port_guid = ntohll(guid->guid);

		print_string(PRINT_ANY, "port guid", ", PORT_GUID %s",

			     ll_addr_n2a((const unsigned char *)&port_guid,

					 sizeof(port_guid), ARPHRD_INFINIBAND,

					 b1, sizeof(b1)));

	}

	if (vf[IFLA_VF_LINK_STATE]) {

		struct ifla_vf_link_state *vf_linkstate =

			RTA_DATA(vf[IFLA_VF_LINK_STATE]);

		if (vf_linkstate->link_state == IFLA_VF_LINK_STATE_AUTO)

			print_string(PRINT_ANY,

				     "link_state",

				     ", link-state %s",

				     "auto");

		else if (vf_linkstate->link_state == IFLA_VF_LINK_STATE_ENABLE)

			print_string(PRINT_ANY,

				     "link_state",

				     ", link-state %s",

				     "enable");

		else

			print_string(PRINT_ANY,

				     "link_state",

				     ", link-state %s",

				     "disable");

	}

	if (vf[IFLA_VF_TRUST]) {

		struct ifla_vf_trust *vf_trust = RTA_DATA(vf[IFLA_VF_TRUST]);

		if (vf_trust->setting != -1)

			print_bool(PRINT_ANY,

				   "trust",

				   vf_trust->setting ? ", trust on" : ", trust off",

				   vf_trust->setting);

	}

	if (vf[IFLA_VF_RSS_QUERY_EN]) {

		struct ifla_vf_rss_query_en *rss_query =

			RTA_DATA(vf[IFLA_VF_RSS_QUERY_EN]);

		if (rss_query->setting != -1)

			print_bool(PRINT_ANY,

				   "query_rss_en",

				   rss_query->setting ? ", query_rss on"

				   : ", query_rss off",

				   rss_query->setting);

	}

	if (vf[IFLA_VF_STATS] && show_stats)

		print_vf_stats64(fp, vf[IFLA_VF_STATS]);

}

void print_num(FILE *fp, unsigned int width, uint64_t count)

{

	const char *prefix = "kMGTPE";

	const unsigned int base = use_iec ? 1024 : 1000;

	uint64_t powi = 1;

	uint16_t powj = 1;

	uint8_t precision = 2;

	char buf[64];

	if (!human_readable || count < base) {

		fprintf(fp, "%-*"PRIu64" ", width, count);

		return;

	}

	/* increase value by a factor of 1000/1024 and print

	 * if result is something a human can read

	 */

	for (;;) {

		powi *= base;

		if (count / base < powi)

			break;

		if (!prefix[1])

			break;

		++prefix;

	}

	/* try to guess a good number of digits for precision */

	for (; precision > 0; precision--) {

		powj *= 10;

		if (count / powi < powj)

			break;

	}

	snprintf(buf, sizeof(buf), "%.*f%c%s", precision,

		 (double) count / powi, *prefix, use_iec ? "i" : "");

	fprintf(fp, "%-*s ", width, buf);

}

static void print_vf_stats64(FILE *fp, struct rtattr *vfstats)

{

	struct rtattr *vf[IFLA_VF_STATS_MAX + 1];

	if (vfstats->rta_type != IFLA_VF_STATS) {

		fprintf(stderr, "BUG: rta type is %d\n", vfstats->rta_type);

		return;

	}

	parse_rtattr_nested(vf, IFLA_VF_STATS_MAX, vfstats);

	if (is_json_context()) {

		open_json_object("stats");

		/* RX stats */

		open_json_object("rx");

		print_u64(PRINT_JSON, "bytes", NULL,

			   rta_getattr_u64(vf[IFLA_VF_STATS_RX_BYTES]));

		print_u64(PRINT_JSON, "packets", NULL,

			   rta_getattr_u64(vf[IFLA_VF_STATS_RX_PACKETS]));

		print_u64(PRINT_JSON, "multicast", NULL,

			   rta_getattr_u64(vf[IFLA_VF_STATS_MULTICAST]));

		print_u64(PRINT_JSON, "broadcast", NULL,

			   rta_getattr_u64(vf[IFLA_VF_STATS_BROADCAST]));

		if (vf[IFLA_VF_STATS_RX_DROPPED])

			print_u64(PRINT_JSON, "dropped", NULL,

				  rta_getattr_u64(vf[IFLA_VF_STATS_RX_DROPPED]));

		close_json_object();

		/* TX stats */

		open_json_object("tx");

		print_u64(PRINT_JSON, "tx_bytes", NULL,

			   rta_getattr_u64(vf[IFLA_VF_STATS_TX_BYTES]));

		print_u64(PRINT_JSON, "tx_packets", NULL,

			   rta_getattr_u64(vf[IFLA_VF_STATS_TX_PACKETS]));

		if (vf[IFLA_VF_STATS_TX_DROPPED])

			print_u64(PRINT_JSON, "dropped", NULL,

				  rta_getattr_u64(vf[IFLA_VF_STATS_TX_DROPPED]));

		close_json_object();

		close_json_object();

	} else {

		/* RX stats */

		fprintf(fp, "%s", _SL_);

		fprintf(fp, "    RX: bytes  packets  mcast   bcast ");

		if (vf[IFLA_VF_STATS_RX_DROPPED])

			fprintf(fp, "  dropped ");

		fprintf(fp, "%s", _SL_);

		fprintf(fp, "    ");

		print_num(fp, 10, rta_getattr_u64(vf[IFLA_VF_STATS_RX_BYTES]));

		print_num(fp, 8, rta_getattr_u64(vf[IFLA_VF_STATS_RX_PACKETS]));

		print_num(fp, 7, rta_getattr_u64(vf[IFLA_VF_STATS_MULTICAST]));

		print_num(fp, 7, rta_getattr_u64(vf[IFLA_VF_STATS_BROADCAST]));

		if (vf[IFLA_VF_STATS_RX_DROPPED])

			print_num(fp, 8, rta_getattr_u64(vf[IFLA_VF_STATS_RX_DROPPED]));

		/* TX stats */

		fprintf(fp, "%s", _SL_);

		fprintf(fp, "    TX: bytes  packets ");

		if (vf[IFLA_VF_STATS_TX_DROPPED])

			fprintf(fp, "  dropped ");

		fprintf(fp, "%s", _SL_);

		fprintf(fp, "    ");

		print_num(fp, 10, rta_getattr_u64(vf[IFLA_VF_STATS_TX_BYTES]));

		print_num(fp, 8, rta_getattr_u64(vf[IFLA_VF_STATS_TX_PACKETS]));

		if (vf[IFLA_VF_STATS_TX_DROPPED])

			print_num(fp, 8, rta_getattr_u64(vf[IFLA_VF_STATS_TX_DROPPED]));

	}

}

static void __print_link_stats(FILE *fp, struct rtattr *tb[])

{

	const struct rtattr *carrier_changes = tb[IFLA_CARRIER_CHANGES];

	struct rtnl_link_stats64 _s, *s = &_;;

	int ret;

	ret = get_rtnl_link_stats_rta(s, tb);

	if (ret < 0)

		return;

	if (is_json_context()) {

		open_json_object((ret == sizeof(*s)) ? "stats64" : "stats");

		/* RX stats */

		open_json_object("rx");

		print_u64(PRINT_JSON, "bytes", NULL, s->rx_bytes);

		print_u64(PRINT_JSON, "packets", NULL, s->rx_packets);

		print_u64(PRINT_JSON, "errors", NULL, s->rx_errors);

		print_u64(PRINT_JSON, "dropped", NULL, s->rx_dropped);

		print_u64(PRINT_JSON, "over_errors", NULL, s->rx_over_errors);

		print_u64(PRINT_JSON, "multicast", NULL, s->multicast);

		if (s->rx_compressed)

			print_u64(PRINT_JSON,

				   "compressed", NULL, s->rx_compressed);

		/* RX error stats */

		if (show_stats > 1) {

			print_u64(PRINT_JSON,

				   "length_errors",

				   NULL, s->rx_length_errors);

			print_u64(PRINT_JSON,

				   "crc_errors",

				   NULL, s->rx_crc_errors);

			print_u64(PRINT_JSON,

				   "frame_errors",

				   NULL, s->rx_frame_errors);

			print_u64(PRINT_JSON,

				   "fifo_errors",

				   NULL, s->rx_fifo_errors);

			print_u64(PRINT_JSON,

				   "missed_errors",

				   NULL, s->rx_missed_errors);

			if (s->rx_nohandler)

				print_u64(PRINT_JSON,

					   "nohandler", NULL, s->rx_nohandler);

		}

		close_json_object();

		/* TX stats */

		open_json_object("tx");

		print_u64(PRINT_JSON, "bytes", NULL, s->tx_bytes);

		print_u64(PRINT_JSON, "packets", NULL, s->tx_packets);

		print_u64(PRINT_JSON, "errors", NULL, s->tx_errors);

		print_u64(PRINT_JSON, "dropped", NULL, s->tx_dropped);

		print_u64(PRINT_JSON,

			   "carrier_errors",

			   NULL, s->tx_carrier_errors);

		print_u64(PRINT_JSON, "collisions", NULL, s->collisions);

		if (s->tx_compressed)

			print_u64(PRINT_JSON,

				   "compressed", NULL, s->tx_compressed);

		/* TX error stats */

		if (show_stats > 1) {

			print_u64(PRINT_JSON,

				   "aborted_errors",

				   NULL, s->tx_aborted_errors);

			print_u64(PRINT_JSON,

				   "fifo_errors",

				   NULL, s->tx_fifo_errors);

			print_u64(PRINT_JSON,

				   "window_errors",

				   NULL, s->tx_window_errors);

			print_u64(PRINT_JSON,

				   "heartbeat_errors",

				   NULL, s->tx_heartbeat_errors);

			if (carrier_changes)

				print_u64(PRINT_JSON, "carrier_changes", NULL,

					   rta_getattr_u32(carrier_changes));

		}

		close_json_object();

		close_json_object();

	} else {

		/* RX stats */

		fprintf(fp, "    RX: bytes  packets  errors  dropped overrun mcast   %s%s",

			s->rx_compressed ? "compressed" : "", _SL_);

		fprintf(fp, "    ");

		print_num(fp, 10, s->rx_bytes);

		print_num(fp, 8, s->rx_packets);

		print_num(fp, 7, s->rx_errors);

		print_num(fp, 7, s->rx_dropped);

		print_num(fp, 7, s->rx_over_errors);

		print_num(fp, 7, s->multicast);

		if (s->rx_compressed)

			print_num(fp, 7, s->rx_compressed);

		/* RX error stats */

		if (show_stats > 1) {

			fprintf(fp, "%s", _SL_);

			fprintf(fp, "    RX errors: length   crc     frame   fifo    missed%s%s",

				s->rx_nohandler ? "   nohandler" : "", _SL_);

			fprintf(fp, "               ");

			print_num(fp, 8, s->rx_length_errors);

			print_num(fp, 7, s->rx_crc_errors);

			print_num(fp, 7, s->rx_frame_errors);

			print_num(fp, 7, s->rx_fifo_errors);

			print_num(fp, 7, s->rx_missed_errors);

			if (s->rx_nohandler)

				print_num(fp, 7, s->rx_nohandler);

		}

		fprintf(fp, "%s", _SL_);

		/* TX stats */

		fprintf(fp, "    TX: bytes  packets  errors  dropped carrier collsns %s%s",

			s->tx_compressed ? "compressed" : "", _SL_);

		fprintf(fp, "    ");

		print_num(fp, 10, s->tx_bytes);

		print_num(fp, 8, s->tx_packets);

		print_num(fp, 7, s->tx_errors);

		print_num(fp, 7, s->tx_dropped);

		print_num(fp, 7, s->tx_carrier_errors);

		print_num(fp, 7, s->collisions);

		if (s->tx_compressed)

			print_num(fp, 7, s->tx_compressed);

		/* TX error stats */

		if (show_stats > 1) {

			fprintf(fp, "%s", _SL_);

			fprintf(fp, "    TX errors: aborted  fifo   window heartbeat");

			if (carrier_changes)

				fprintf(fp, " transns");

			fprintf(fp, "%s", _SL_);

			fprintf(fp, "               ");

			print_num(fp, 8, s->tx_aborted_errors);

			print_num(fp, 7, s->tx_fifo_errors);

			print_num(fp, 7, s->tx_window_errors);

			print_num(fp, 7, s->tx_heartbeat_errors);

			if (carrier_changes)

				print_num(fp, 7,

					  rta_getattr_u32(carrier_changes));

		}

	}

}

static void print_link_stats(FILE *fp, struct nlmsghdr *n)

{

	struct ifinfomsg *ifi = NLMSG_DATA(n);

	struct rtattr *tb[IFLA_MAX+1];

	parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi),

		     n->nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)));

	__print_link_stats(fp, tb);

	print_nl();

}

static int print_linkinfo_brief(FILE *fp, const char *name,

				const struct ifinfomsg *ifi,

				struct rtattr *tb[])

{

	unsigned int m_flag = 0;

	m_flag = print_name_and_link("%-16s ", name, tb);

	if (tb[IFLA_OPERSTATE])

		print_operstate(fp, rta_getattr_u8(tb[IFLA_OPERSTATE]));

	if (filter.family == AF_PACKET) {

		SPRINT_BUF(b1);

		if (tb[IFLA_ADDRESS]) {

			print_color_string(PRINT_ANY, COLOR_MAC,

					   "address", "%s ",

					   ll_addr_n2a(

						   RTA_DATA(tb[IFLA_ADDRESS]),

						   RTA_PAYLOAD(tb[IFLA_ADDRESS]),

						   ifi->ifi_type,

						   b1, sizeof(b1)));

		}

	}

	if (filter.family == AF_PACKET) {

		print_link_flags(fp, ifi->ifi_flags, m_flag);

		print_string(PRINT_FP, NULL, "%s", "\n");

	}

	fflush(fp);

	return 0;

}

static const char *link_events[] = {

	[IFLA_EVENT_NONE] = "NONE",

	[IFLA_EVENT_REBOOT] = "REBOOT",

	[IFLA_EVENT_FEATURES] = "FEATURE CHANGE",

	[IFLA_EVENT_BONDING_FAILOVER] = "BONDING FAILOVER",

	[IFLA_EVENT_NOTIFY_PEERS] = "NOTIFY PEERS",

	[IFLA_EVENT_IGMP_RESEND] = "RESEND IGMP",

	[IFLA_EVENT_BONDING_OPTIONS] = "BONDING OPTION"

};

static void print_link_event(FILE *f, __u32 event)

{

	if (event >= ARRAY_SIZE(link_events))

		print_int(PRINT_ANY, "event", "event %d ", event);

	else {

		if (event)

			print_string(PRINT_ANY,

				     "event", "event %s ",

				     link_events[event]);

	}

}

int print_linkinfo(struct nlmsghdr *n, void *arg)

{

	FILE *fp = (FILE *)arg;

	struct ifinfomsg *ifi = NLMSG_DATA(n);