/*

 * ipmacsec.c		"ip macsec".

 *

 *		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:	Sabrina Dubroca <sd@queasysnail.net>

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <linux/genetlink.h>

#include <linux/if_ether.h>

#include <linux/if_macsec.h>

#include "rt_names.h"

#include "utils.h"

#include "ip_common.h"

#include "ll_map.h"

#include "libgenl.h"

static const char * const values_on_off[] = { "off", "on" };

static const char * const validate_str[] = {

	[MACSEC_VALIDATE_DISABLED] = "disabled",

	[MACSEC_VALIDATE_CHECK] = "check",

	[MACSEC_VALIDATE_STRICT] = "strict",

};

static const char * const offload_str[] = {

	[MACSEC_OFFLOAD_OFF] = "off",

	[MACSEC_OFFLOAD_PHY] = "phy",

	[MACSEC_OFFLOAD_MAC] = "mac",

};

struct sci {

	__u64 sci;

	__u16 port;

	char abuf[6];

};

struct sa_desc {

	__u8 an;

	__u32 pn;

	__u8 key_id[MACSEC_KEYID_LEN];

	__u32 key_len;

	__u8 key[MACSEC_MAX_KEY_LEN];

	__u8 active;

};

struct cipher_args {

	__u64 id;

	__u8 icv_len;

};

struct txsc_desc {

	int ifindex;

	__u64 sci;

	__be16 port;

	struct cipher_args cipher;

	__u32 window;

	enum macsec_validation_type validate;

	__u8 encoding_sa;

};

struct rxsc_desc {

	int ifindex;

	__u64 sci;

	__u8 active;

};

#define MACSEC_BUFLEN 1024

/* netlink socket */

static struct rtnl_handle genl_rth;

static int genl_family = -1;

#define MACSEC_GENL_REQ(_req, _bufsiz, _cmd, _flags) \

	GENL_REQUEST(_req, _bufsiz, genl_family, 0, MACSEC_GENL_VERSION, \

		     _cmd, _flags)

static void ipmacsec_usage(void)

{

	fprintf(stderr,

		"Usage: ip macsec add DEV tx sa { 0..3 } [ OPTS ] key ID KEY\n"

		"       ip macsec set DEV tx sa { 0..3 } [ OPTS ]\n"

		"       ip macsec del DEV tx sa { 0..3 }\n"

		"       ip macsec add DEV rx SCI [ on | off ]\n"

		"       ip macsec set DEV rx SCI [ on | off ]\n"

		"       ip macsec del DEV rx SCI\n"

		"       ip macsec add DEV rx SCI sa { 0..3 } [ OPTS ] key ID KEY\n"

		"       ip macsec set DEV rx SCI sa { 0..3 } [ OPTS ]\n"

		"       ip macsec del DEV rx SCI sa { 0..3 }\n"

		"       ip macsec show\n"

		"       ip macsec show DEV\n"

		"       ip macsec offload DEV [ off | phy | mac ]\n"

		"where  OPTS := [ pn <u32> ] [ on | off ]\n"

		"       ID   := 128-bit hex string\n"

		"       KEY  := 128-bit or 256-bit hex string\n"

		"       SCI  := { sci <u64> | port { 1..2^16-1 } address <lladdr> }\n");

	exit(-1);

}

static int one_of(const char *msg, const char *realval, const char * const *list,

		  size_t len, int *index)

{

	int i;

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

		if (matches(realval, list[i]) == 0) {

			*index = i;

			return 0;

		}

	}

	fprintf(stderr, "Error: argument of \"%s\" must be one of ", msg);

	for (i = 0; i < len; i++)

		fprintf(stderr, "\"%s\", ", list[i]);

	fprintf(stderr, "not \"%s\"\n", realval);

	return -1;

}

static int get_an(__u8 *val, const char *arg)

{

	int ret = get_u8(val, arg, 0);

	if (ret)

		return ret;

	if (*val > 3)

		return -1;

	return 0;

}

static int get_sci(__u64 *sci, const char *arg)

{

	return get_be64(sci, arg, 16);

}

static int get_port(__be16 *port, const char *arg)

{

	return get_be16(port, arg, 0);

}

#define _STR(a) #a

#define STR(a) _STR(a)

static void get_icvlen(__u8 *icvlen, char *arg)

{

	int ret = get_u8(icvlen, arg, 10);

	if (ret)

		invarg("expected ICV length", arg);

	if (*icvlen < MACSEC_MIN_ICV_LEN || *icvlen > MACSEC_STD_ICV_LEN)

		invarg("ICV length must be in the range {"

		       STR(MACSEC_MIN_ICV_LEN) ".." STR(MACSEC_STD_ICV_LEN)

		       "}", arg);

}

static bool get_sa(int *argcp, char ***argvp, __u8 *an)

{

	int argc = *argcp;

	char **argv = *argvp;

	int ret;

	if (argc <= 0 || strcmp(*argv, "sa") != 0)

		return false;

	NEXT_ARG();

	ret = get_an(an, *argv);

	if (ret)

		invarg("expected an { 0..3 }", *argv);

	argc--; argv++;

	*argvp = argv;

	*argcp = argc;

	return true;

}

static int parse_sa_args(int *argcp, char ***argvp, struct sa_desc *sa)

{

	int argc = *argcp;

	char **argv = *argvp;

	int ret;

	bool active_set = false;

	while (argc > 0) {

		if (strcmp(*argv, "pn") == 0) {

			if (sa->pn != 0)

				duparg2("pn", "pn");

			NEXT_ARG();

			ret = get_u32(&sa->pn, *argv, 0);

			if (ret)

				invarg("expected pn", *argv);

			if (sa->pn == 0)

				invarg("expected pn != 0", *argv);

		} else if (strcmp(*argv, "key") == 0) {

			unsigned int len;

			NEXT_ARG();

			if (!hexstring_a2n(*argv, sa->key_id, MACSEC_KEYID_LEN,

					   &len))

				invarg("expected key id", *argv);

			NEXT_ARG();

			if (!hexstring_a2n(*argv, sa->key, MACSEC_MAX_KEY_LEN,

					   &sa->key_len))

				invarg("expected key", *argv);

		} else if (strcmp(*argv, "on") == 0) {

			if (active_set)

				duparg2("on/off", "on");

			sa->active = true;

			active_set = true;

		} else if (strcmp(*argv, "off") == 0) {

			if (active_set)

				duparg2("on/off", "off");

			sa->active = false;

			active_set = true;

		} else {

			fprintf(stderr, "macsec: unknown command \"%s\"?\n",

				*argv);

			ipmacsec_usage();

		}

		argv++; argc--;

	}

	*argvp = argv;

	*argcp = argc;

	return 0;

}

static __u64 make_sci(char *addr, __be16 port)

{

	__u64 sci;

	memcpy(&sci, addr, ETH_ALEN);

	memcpy(((char *)&sci) + ETH_ALEN, &port, sizeof(port));

	return sci;

}

static bool sci_complete(bool sci, bool port, bool addr, bool port_only)

{

	return sci || (port && (addr || port_only));

}

static int get_sci_portaddr(struct sci *sci, int *argcp, char ***argvp,

			    bool port_only, bool optional)

{

	int argc = *argcp;

	char **argv = *argvp;

	int ret;

	bool p = false, a = false, s = false;

	while (argc > 0) {

		if (strcmp(*argv, "sci") == 0) {

			if (p)

				invarg("expected address", *argv);

			if (a)

				invarg("expected port", *argv);

			NEXT_ARG();

			ret = get_sci(&sci->sci, *argv);

			if (ret)

				invarg("expected sci", *argv);

			s = true;

		} else if (strcmp(*argv, "port") == 0) {

			NEXT_ARG();

			ret = get_port(&sci->port, *argv);

			if (ret)

				invarg("expected port", *argv);

			if (sci->port == 0)

				invarg("expected port != 0", *argv);

			p = true;

		} else if (strcmp(*argv, "address") == 0) {

			NEXT_ARG();

			ret = ll_addr_a2n(sci->abuf, sizeof(sci->abuf), *argv);

			if (ret < 0)

				invarg("expected lladdr", *argv);

			a = true;

		} else if (optional) {

			break;

		} else {

			invarg("expected sci, port, or address", *argv);

		}

		argv++; argc--;

		if (sci_complete(s, p, a, port_only))

			break;

	}

	if (!optional && !sci_complete(s, p, a, port_only))

		return -1;

	if (p && a)

		sci->sci = make_sci(sci->abuf, sci->port);

	*argvp = argv;

	*argcp = argc;

	return p || a || s;

}

static bool parse_rxsci(int *argcp, char ***argvp, struct rxsc_desc *rxsc,

			struct sa_desc *rxsa)

{

	struct sci sci = { 0 };

	if (*argcp == 0 ||

	    get_sci_portaddr(&sci, argcp, argvp, false, false) < 0) {

		fprintf(stderr, "expected sci\n");

		ipmacsec_usage();

	}

	rxsc->sci = sci.sci;

	return get_sa(argcp, argvp, &rxsa->an);

}

static int parse_rxsci_args(int *argcp, char ***argvp, struct rxsc_desc *rxsc)

{

	int argc = *argcp;

	char **argv = *argvp;

	bool active_set = false;

	while (argc > 0) {

		if (strcmp(*argv, "on") == 0) {

			if (active_set)

				duparg2("on/off", "on");

			rxsc->active = true;

			active_set = true;

		} else if (strcmp(*argv, "off") == 0) {

			if (active_set)

				duparg2("on/off", "off");

			rxsc->active = false;

			active_set = true;

		} else {

			fprintf(stderr, "macsec: unknown command \"%s\"?\n",

				*argv);

			ipmacsec_usage();

		}

		argv++; argc--;

	}

	*argvp = argv;

	*argcp = argc;

	return 0;

}

enum cmd {

	CMD_ADD,

	CMD_DEL,

	CMD_UPD,

	CMD_OFFLOAD,

	__CMD_MAX

};

static const enum macsec_nl_commands macsec_commands[__CMD_MAX][2][2] = {

	[CMD_ADD] = {

		[0] = {-1, MACSEC_CMD_ADD_RXSC},

		[1] = {MACSEC_CMD_ADD_TXSA, MACSEC_CMD_ADD_RXSA},

	},

	[CMD_UPD] = {

		[0] = {-1, MACSEC_CMD_UPD_RXSC},

		[1] = {MACSEC_CMD_UPD_TXSA, MACSEC_CMD_UPD_RXSA},

	},

	[CMD_DEL] = {

		[0] = {-1, MACSEC_CMD_DEL_RXSC},

		[1] = {MACSEC_CMD_DEL_TXSA, MACSEC_CMD_DEL_RXSA},

	},

	[CMD_OFFLOAD] = {

		[0] = {-1, MACSEC_CMD_UPD_OFFLOAD },

	},

};

static int do_modify_nl(enum cmd c, enum macsec_nl_commands cmd, int ifindex,

			struct rxsc_desc *rxsc, struct sa_desc *sa)

{

	struct rtattr *attr_sa;

	MACSEC_GENL_REQ(req, MACSEC_BUFLEN, cmd, NLM_F_REQUEST);

	addattr32(&req.n, MACSEC_BUFLEN, MACSEC_ATTR_IFINDEX, ifindex);

	if (rxsc) {

		struct rtattr *attr_rxsc;

		attr_rxsc = addattr_nest(&req.n, MACSEC_BUFLEN,

					 MACSEC_ATTR_RXSC_CONFIG);

		addattr64(&req.n, MACSEC_BUFLEN,

			  MACSEC_RXSC_ATTR_SCI, rxsc->sci);

		if (c != CMD_DEL && rxsc->active != 0xff)

			addattr8(&req.n, MACSEC_BUFLEN,

				 MACSEC_RXSC_ATTR_ACTIVE, rxsc->active);

		addattr_nest_end(&req.n, attr_rxsc);

	}

	if (sa->an == 0xff)

		goto talk;

	attr_sa = addattr_nest(&req.n, MACSEC_BUFLEN, MACSEC_ATTR_SA_CONFIG);

	addattr8(&req.n, MACSEC_BUFLEN, MACSEC_SA_ATTR_AN, sa->an);

	if (c != CMD_DEL) {

		if (sa->pn)

			addattr32(&req.n, MACSEC_BUFLEN, MACSEC_SA_ATTR_PN,

				  sa->pn);

		if (sa->key_len) {

			addattr_l(&req.n, MACSEC_BUFLEN, MACSEC_SA_ATTR_KEYID,

				  sa->key_id, MACSEC_KEYID_LEN);

			addattr_l(&req.n, MACSEC_BUFLEN, MACSEC_SA_ATTR_KEY,

				  sa->key, sa->key_len);

		}

		if (sa->active != 0xff) {

			addattr8(&req.n, MACSEC_BUFLEN,

				 MACSEC_SA_ATTR_ACTIVE, sa->active);

		}

	}

	addattr_nest_end(&req.n, attr_sa);

talk:

	if (rtnl_talk(&genl_rth, &req.n, NULL) < 0)

		return -2;

	return 0;

}

static bool check_sa_args(enum cmd c, struct sa_desc *sa)

{

	if (c == CMD_ADD) {

		if (!sa->key_len) {

			fprintf(stderr, "cannot create SA without key\n");

			return -1;

		}

		if (sa->pn == 0) {

			fprintf(stderr, "must specify a packet number != 0\n");

			return -1;

		}

	} else if (c == CMD_UPD) {

		if (sa->key_len) {

			fprintf(stderr, "cannot change key on SA\n");

			return -1;

		}

	}

	return 0;

}

static int do_modify_txsa(enum cmd c, int argc, char **argv, int ifindex)

{

	struct sa_desc txsa = {0};

	enum macsec_nl_commands cmd;

	txsa.an = 0xff;

	txsa.active = 0xff;

	if (argc == 0 || !get_sa(&argc, &argv, &txsa.an))

		ipmacsec_usage();

	if (c == CMD_DEL)

		goto modify;

	if (parse_sa_args(&argc, &argv, &txsa))

		return -1;

	if (check_sa_args(c, &txsa))

		return -1;

modify:

	cmd = macsec_commands[c][1][0];

	return do_modify_nl(c, cmd, ifindex, NULL, &txsa);

}

static int do_modify_rxsci(enum cmd c, int argc, char **argv, int ifindex)

{

	struct rxsc_desc rxsc = {0};

	struct sa_desc rxsa = {0};

	bool sa_set;

	enum macsec_nl_commands cmd;

	rxsc.ifindex = ifindex;

	rxsc.active = 0xff;

	rxsa.an = 0xff;

	rxsa.active = 0xff;

	sa_set = parse_rxsci(&argc, &argv, &rxsc, &rxsa);

	if (c == CMD_DEL)

		goto modify;

	if (sa_set && (parse_sa_args(&argc, &argv, &rxsa) ||

		       check_sa_args(c, &rxsa)))

		return -1;

	if (!sa_set && parse_rxsci_args(&argc, &argv, &rxsc))

		return -1;

modify:

	cmd = macsec_commands[c][sa_set][1];

	return do_modify_nl(c, cmd, rxsc.ifindex, &rxsc, &rxsa);

}

static int do_modify(enum cmd c, int argc, char **argv)

{

	int ifindex;

	if (argc == 0)

		ipmacsec_usage();

	ifindex = ll_name_to_index(*argv);

	if (!ifindex) {

		fprintf(stderr, "Device \"%s\" does not exist.\n", *argv);

		return -1;

	}

	argc--; argv++;

	if (argc == 0)

		ipmacsec_usage();

	if (strcmp(*argv, "tx") == 0)

		return do_modify_txsa(c, argc-1, argv+1, ifindex);

	if (strcmp(*argv, "rx") == 0)

		return do_modify_rxsci(c, argc-1, argv+1, ifindex);

	ipmacsec_usage();

	return -1;

}

static int do_offload(enum cmd c, int argc, char **argv)

{

	enum macsec_offload offload;

	struct rtattr *attr;

	int ifindex, ret;

	if (argc == 0)

		ipmacsec_usage();

	ifindex = ll_name_to_index(*argv);

	if (!ifindex) {

		fprintf(stderr, "Device \"%s\" does not exist.\n", *argv);

		return -1;

	}

	argc--; argv++;

	if (argc == 0)

		ipmacsec_usage();

	ret = one_of("offload", *argv, offload_str, ARRAY_SIZE(offload_str),

		     (int *)&offload);

	if (ret)

		ipmacsec_usage();

	MACSEC_GENL_REQ(req, MACSEC_BUFLEN, macsec_commands[c][0][1], NLM_F_REQUEST);

	addattr32(&req.n, MACSEC_BUFLEN, MACSEC_ATTR_IFINDEX, ifindex);

	attr = addattr_nest(&req.n, MACSEC_BUFLEN, MACSEC_ATTR_OFFLOAD);

	addattr8(&req.n, MACSEC_BUFLEN, MACSEC_OFFLOAD_ATTR_TYPE, offload);

	addattr_nest_end(&req.n, attr);

	if (rtnl_talk(&genl_rth, &req.n, NULL) < 0)

		return -2;

	return 0;

}

/* dump/show */

static struct {

	int ifindex;

	__u64 sci;

} filter;

static int validate_dump(struct rtattr **attrs)

{

	return attrs[MACSEC_ATTR_IFINDEX] && attrs[MACSEC_ATTR_SECY] &&

	       attrs[MACSEC_ATTR_TXSA_LIST] && attrs[MACSEC_ATTR_RXSC_LIST] &&

	       attrs[MACSEC_ATTR_TXSC_STATS] && attrs[MACSEC_ATTR_SECY_STATS];

}

static int validate_secy_dump(struct rtattr **attrs)

{

	return attrs[MACSEC_SECY_ATTR_SCI] &&

	       attrs[MACSEC_SECY_ATTR_ENCODING_SA] &&

	       attrs[MACSEC_SECY_ATTR_CIPHER_SUITE] &&

	       attrs[MACSEC_SECY_ATTR_ICV_LEN] &&

	       attrs[MACSEC_SECY_ATTR_PROTECT] &&

	       attrs[MACSEC_SECY_ATTR_REPLAY] &&

	       attrs[MACSEC_SECY_ATTR_OPER] &&

	       attrs[MACSEC_SECY_ATTR_VALIDATE] &&

	       attrs[MACSEC_SECY_ATTR_ENCRYPT] &&

	       attrs[MACSEC_SECY_ATTR_INC_SCI] &&

	       attrs[MACSEC_SECY_ATTR_ES] &&

	       attrs[MACSEC_SECY_ATTR_SCB];

}

static void print_flag(struct rtattr *attrs[], const char *desc,

		       int field)

{

	__u8 flag;

	if (!attrs[field])

		return;

	flag = rta_getattr_u8(attrs[field]);

	if (is_json_context())

		print_bool(PRINT_JSON, desc, NULL, flag);

	else {

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

		print_string(PRINT_FP, NULL, "%s ",

			     flag ? "on" : "off");

	}

}

static void print_key(struct rtattr *key)

{

	SPRINT_BUF(keyid);

	print_string(PRINT_ANY, "key", " key %s\n",

		     hexstring_n2a(RTA_DATA(key), RTA_PAYLOAD(key),

				   keyid, sizeof(keyid)));

}

#define CIPHER_NAME_GCM_AES_128 "GCM-AES-128"

#define CIPHER_NAME_GCM_AES_256 "GCM-AES-256"

#define DEFAULT_CIPHER_NAME CIPHER_NAME_GCM_AES_128

static const char *cs_id_to_name(__u64 cid)

{

	switch (cid) {

	case MACSEC_DEFAULT_CIPHER_ID:

		return DEFAULT_CIPHER_NAME;

	case MACSEC_CIPHER_ID_GCM_AES_128:

	     /* MACSEC_DEFAULT_CIPHER_ALT: */

		return CIPHER_NAME_GCM_AES_128;

	case MACSEC_CIPHER_ID_GCM_AES_256:

		return CIPHER_NAME_GCM_AES_256;

	default:

		return "(unknown)";

	}

}

static const char *validate_to_str(__u8 validate)

{

	if (validate >= ARRAY_SIZE(validate_str))

		return "(unknown)";

	return validate_str[validate];

}

static const char *offload_to_str(__u8 offload)

{

	if (offload >= ARRAY_SIZE(offload_str))

		return "(unknown)";

	return offload_str[offload];

}

static void print_attrs(struct rtattr *attrs[])

{

	print_flag(attrs, "protect", MACSEC_SECY_ATTR_PROTECT);

	if (attrs[MACSEC_SECY_ATTR_VALIDATE]) {

		__u8 val = rta_getattr_u8(attrs[MACSEC_SECY_ATTR_VALIDATE]);

		print_string(PRINT_ANY, "validate",

			     "validate %s ", validate_to_str(val));

	}

	print_flag(attrs, "sc", MACSEC_RXSC_ATTR_ACTIVE);

	print_flag(attrs, "sa", MACSEC_SA_ATTR_ACTIVE);

	print_flag(attrs, "encrypt", MACSEC_SECY_ATTR_ENCRYPT);

	print_flag(attrs, "send_sci", MACSEC_SECY_ATTR_INC_SCI);

	print_flag(attrs, "end_station", MACSEC_SECY_ATTR_ES);

	print_flag(attrs, "scb", MACSEC_SECY_ATTR_SCB);

	print_flag(attrs, "replay", MACSEC_SECY_ATTR_REPLAY);

	if (attrs[MACSEC_SECY_ATTR_WINDOW]) {

		__u32 win = rta_getattr_u32(attrs[MACSEC_SECY_ATTR_WINDOW]);

		print_uint(PRINT_ANY, "window", "window %u ", win);

	}

	if (attrs[MACSEC_SECY_ATTR_CIPHER_SUITE]) {

		__u64 cid = rta_getattr_u64(attrs[MACSEC_SECY_ATTR_CIPHER_SUITE]);

		print_nl();

		print_string(PRINT_ANY, "cipher_suite",

			     "    cipher suite: %s,", cs_id_to_name(cid));

	}

	if (attrs[MACSEC_SECY_ATTR_ICV_LEN]) {

		__u8 icv_len = rta_getattr_u8(attrs[MACSEC_SECY_ATTR_ICV_LEN]);

		print_uint(PRINT_ANY, "icv_length",

		     " using ICV length %u\n", icv_len);

	}

}

static __u64 getattr_u64(const struct rtattr *stat)

{

	size_t len = RTA_PAYLOAD(stat);

	switch (len) {

	case sizeof(__u64):

		return rta_getattr_u64(stat);

	case sizeof(__u32):

		return rta_getattr_u32(stat);

	case sizeof(__u16):

		return rta_getattr_u16(stat);

	case sizeof(__u8):

		return rta_getattr_u8(stat);

	default:

		fprintf(stderr, "invalid attribute length %zu\n",

			len);

		exit(-1);

	}

}

static void print_fp_stats(const char *prefix,

			   const char *names[], unsigned int num,

			   struct rtattr *stats[])

{

	unsigned int i;

	int pad;

	printf("%sstats:", prefix);

	for (i = 1; i < num; i++) {

		if (!names[i])

			continue;

		printf(" %s", names[i]);

	}

	printf("\n%s      ", prefix);

	for (i = 1; i < num; i++) {

		if (!names[i])

			continue;

		pad = strlen(names[i]) + 1;

		if (stats[i])

			printf("%*llu", pad, getattr_u64(stats[i]));

		else

			printf("%*c", pad, '-');

	}

	printf("\n");

}

static void print_json_stats(const char *names[], unsigned int num,

			     struct rtattr *stats[])

{

	unsigned int i;

	for (i = 1; i < num; i++) {

		if (!names[i] || !stats[i])

			continue;

		print_u64(PRINT_JSON, names[i],

			   NULL, getattr_u64(stats[i]));

	}

}

static void print_stats(const char *prefix,

			const char *names[], unsigned int num,

			struct rtattr *stats[])

{

	if (is_json_context())

		print_json_stats(names, num, stats);

	else

		print_fp_stats(prefix, names, num, stats);

}

static const char *txsc_stats_names[NUM_MACSEC_TXSC_STATS_ATTR] = {

	[MACSEC_TXSC_STATS_ATTR_OUT_PKTS_PROTECTED] = "OutPktsProtected",

	[MACSEC_TXSC_STATS_ATTR_OUT_PKTS_ENCRYPTED] = "OutPktsEncrypted",

	[MACSEC_TXSC_STATS_ATTR_OUT_OCTETS_PROTECTED] = "OutOctetsProtected",

	[MACSEC_TXSC_STATS_ATTR_OUT_OCTETS_ENCRYPTED] = "OutOctetsEncrypted",

};

static void print_txsc_stats(const char *prefix, struct rtattr *attr)

{

	struct rtattr *stats[MACSEC_TXSC_STATS_ATTR_MAX + 1];

	if (!attr || show_stats == 0)

		return;

	parse_rtattr_nested(stats, MACSEC_TXSC_STATS_ATTR_MAX, attr);

	print_stats(prefix, txsc_stats_names, NUM_MACSEC_TXSC_STATS_ATTR,

		    stats);

}

static const char *secy_stats_names[NUM_MACSEC_SECY_STATS_ATTR] = {

	[MACSEC_SECY_STATS_ATTR_OUT_PKTS_UNTAGGED] = "OutPktsUntagged",

	[MACSEC_SECY_STATS_ATTR_IN_PKTS_UNTAGGED] = "InPktsUntagged",

	[MACSEC_SECY_STATS_ATTR_OUT_PKTS_TOO_LONG] = "OutPktsTooLong",

	[MACSEC_SECY_STATS_ATTR_IN_PKTS_NO_TAG] = "InPktsNoTag",

	[MACSEC_SECY_STATS_ATTR_IN_PKTS_BAD_TAG] = "InPktsBadTag",

	[MACSEC_SECY_STATS_ATTR_IN_PKTS_UNKNOWN_SCI] = "InPktsUnknownSCI",

	[MACSEC_SECY_STATS_ATTR_IN_PKTS_NO_SCI] = "InPktsNoSCI",

	[MACSEC_SECY_STATS_ATTR_IN_PKTS_OVERRUN] = "InPktsOverrun",

};

static void print_secy_stats(const char *prefix, struct rtattr *attr)

{

	struct rtattr *stats[MACSEC_SECY_STATS_ATTR_MAX + 1];

	if (!attr || show_stats == 0)

		return;

	parse_rtattr_nested(stats, MACSEC_SECY_STATS_ATTR_MAX, attr);

	print_stats(prefix, secy_stats_names,

		    NUM_MACSEC_SECY_STATS_ATTR, stats);

}

static const char *rxsa_stats_names[NUM_MACSEC_SA_STATS_ATTR] = {

	[MACSEC_SA_STATS_ATTR_IN_PKTS_OK] = "InPktsOK",

	[MACSEC_SA_STATS_ATTR_IN_PKTS_INVALID] = "InPktsInvalid",

	[MACSEC_SA_STATS_ATTR_IN_PKTS_NOT_VALID] = "InPktsNotValid",

	[MACSEC_SA_STATS_ATTR_IN_PKTS_NOT_USING_SA] = "InPktsNotUsingSA",

	[MACSEC_SA_STATS_ATTR_IN_PKTS_UNUSED_SA] = "InPktsUnusedSA",

};

static void print_rxsa_stats(const char *prefix, struct rtattr *attr)

{

	struct rtattr *stats[MACSEC_SA_STATS_ATTR_MAX + 1];

	if (!attr || show_stats == 0)

		return;

	parse_rtattr_nested(stats, MACSEC_SA_STATS_ATTR_MAX, attr);

	print_stats(prefix, rxsa_stats_names, NUM_MACSEC_SA_STATS_ATTR, stats);

}

static const char *txsa_stats_names[NUM_MACSEC_SA_STATS_ATTR] = {

	[MACSEC_SA_STATS_ATTR_OUT_PKTS_PROTECTED] = "OutPktsProtected",

	[MACSEC_SA_STATS_ATTR_OUT_PKTS_ENCRYPTED] = "OutPktsEncrypted",

};

static void print_txsa_stats(const char *prefix, struct rtattr *attr)

{

	struct rtattr *stats[MACSEC_SA_STATS_ATTR_MAX + 1];

	if (!attr || show_stats == 0)

		return;

	parse_rtattr_nested(stats, MACSEC_SA_STATS_ATTR_MAX, attr);

	print_stats(prefix, txsa_stats_names, NUM_MACSEC_SA_STATS_ATTR, stats);

}

static void print_tx_sc(const char *prefix, __u64 sci, __u8 encoding_sa,

			struct rtattr *txsc_stats, struct rtattr *secy_stats,

			struct rtattr *sa)

{

	struct rtattr *sa_attr[MACSEC_SA_ATTR_MAX + 1];

	struct rtattr *a;

	int rem;

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

	print_0xhex(PRINT_ANY, "sci",

		    "TXSC: %016llx", ntohll(sci));