/*

 * f_flower.c		Flower Classifier

 *

 *		This program is free software; you can distribute 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:     Jiri Pirko <jiri@resnulli.us>

 */

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <net/if.h>

#include <linux/limits.h>

#include <linux/if_arp.h>

#include <linux/if_ether.h>

#include <linux/ip.h>

#include <linux/tc_act/tc_vlan.h>

#include <linux/mpls.h>

#include "utils.h"

#include "tc_util.h"

#include "rt_names.h"

enum flower_matching_flags {

	FLOWER_IP_FLAGS,

};

enum flower_endpoint {

	FLOWER_ENDPOINT_SRC,

	FLOWER_ENDPOINT_DST

};

enum flower_icmp_field {

	FLOWER_ICMP_FIELD_TYPE,

	FLOWER_ICMP_FIELD_CODE

};

static void explain(void)

{

	fprintf(stderr,

		"Usage: ... flower	[ MATCH-LIST ] [ verbose ]\n"

		"			[ skip_sw | skip_hw ]\n"

		"			[ action ACTION-SPEC ] [ classid CLASSID ]\n"

		"\n"

		"Where: MATCH-LIST := [ MATCH-LIST ] MATCH\n"

		"       MATCH      := {	indev DEV-NAME |\n"

		"			vlan_id VID |\n"

		"			vlan_prio PRIORITY |\n"

		"			vlan_ethtype [ ipv4 | ipv6 | ETH-TYPE ] |\n"

		"			cvlan_id VID |\n"

		"			cvlan_prio PRIORITY |\n"

		"			cvlan_ethtype [ ipv4 | ipv6 | ETH-TYPE ] |\n"

		"			dst_mac MASKED-LLADDR |\n"

		"			src_mac MASKED-LLADDR |\n"

		"			ip_proto [tcp | udp | sctp | icmp | icmpv6 | IP-PROTO ] |\n"

		"			ip_tos MASKED-IP_TOS |\n"

		"			ip_ttl MASKED-IP_TTL |\n"

		"			mpls_label LABEL |\n"

		"			mpls_tc TC |\n"

		"			mpls_bos BOS |\n"

		"			mpls_ttl TTL |\n"

		"			dst_ip PREFIX |\n"

		"			src_ip PREFIX |\n"

		"			dst_port PORT-NUMBER |\n"

		"			src_port PORT-NUMBER |\n"

		"			tcp_flags MASKED-TCP_FLAGS |\n"

		"			type MASKED-ICMP-TYPE |\n"

		"			code MASKED-ICMP-CODE |\n"

		"			arp_tip IPV4-PREFIX |\n"

		"			arp_sip IPV4-PREFIX |\n"

		"			arp_op [ request | reply | OP ] |\n"

		"			arp_tha MASKED-LLADDR |\n"

		"			arp_sha MASKED-LLADDR |\n"

		"			enc_dst_ip [ IPV4-ADDR | IPV6-ADDR ] |\n"

		"			enc_src_ip [ IPV4-ADDR | IPV6-ADDR ] |\n"

		"			enc_key_id [ KEY-ID ] |\n"

		"			enc_tos MASKED-IP_TOS |\n"

		"			enc_ttl MASKED-IP_TTL |\n"

		"			geneve_opts MASKED-OPTIONS |\n"

		"			ip_flags IP-FLAGS | \n"

		"			enc_dst_port [ port_number ] }\n"

		"	FILTERID := X:Y:Z\n"

		"	MASKED_LLADDR := { LLADDR | LLADDR/MASK | LLADDR/BITS }\n"

		"	ACTION-SPEC := ... look at individual actions\n"

		"\n"

		"NOTE:	CLASSID, IP-PROTO are parsed as hexadecimal input.\n"

		"NOTE:	There can be only used one mask per one prio. If user needs\n"

		"	to specify different mask, he has to use different prio.\n");

}

static int flower_parse_eth_addr(char *str, int addr_type, int mask_type,

				 struct nlmsghdr *n)

{

	int ret, err = -1;

	char addr[ETH_ALEN], *slash;

	slash = strchr(str, '/');

	if (slash)

		*slash = '\0';

	ret = ll_addr_a2n(addr, sizeof(addr), str);

	if (ret < 0)

		goto err;

	addattr_l(n, MAX_MSG, addr_type, addr, sizeof(addr));

	if (slash) {

		unsigned bits;

		if (!get_unsigned(&bits, slash + 1, 10)) {

			uint64_t mask;

			/* Extra 16 bit shift to push mac address into

			 * high bits of uint64_t

			 */

			mask = htonll(0xffffffffffffULL << (16 + 48 - bits));

			memcpy(addr, &mask, ETH_ALEN);

		} else {

			ret = ll_addr_a2n(addr, sizeof(addr), slash + 1);

			if (ret < 0)

				goto err;

		}

	} else {

		memset(addr, 0xff, ETH_ALEN);

	}

	addattr_l(n, MAX_MSG, mask_type, addr, sizeof(addr));

	err = 0;

err:

	if (slash)

		*slash = '/';

	return err;

}

static bool eth_type_vlan(__be16 ethertype)

{

	return ethertype == htons(ETH_P_8021Q) ||

	       ethertype == htons(ETH_P_8021AD);

}

static int flower_parse_vlan_eth_type(char *str, __be16 eth_type, int type,

				      __be16 *p_vlan_eth_type,

				      struct nlmsghdr *n)

{

	__be16 vlan_eth_type;

	if (!eth_type_vlan(eth_type)) {

		fprintf(stderr, "Can't set \"%s\" if ethertype isn't 802.1Q or 802.1AD\n",

			type == TCA_FLOWER_KEY_VLAN_ETH_TYPE ? "vlan_ethtype" : "cvlan_ethtype");

		return -1;

	}

	if (ll_proto_a2n(&vlan_eth_type, str))

		invarg("invalid vlan_ethtype", str);

	addattr16(n, MAX_MSG, type, vlan_eth_type);

	*p_vlan_eth_type = vlan_eth_type;

	return 0;

}

struct flag_to_string {

	int flag;

	enum flower_matching_flags type;

	char *string;

};

static struct flag_to_string flags_str[] = {

	{ TCA_FLOWER_KEY_FLAGS_IS_FRAGMENT, FLOWER_IP_FLAGS, "frag" },

	{ TCA_FLOWER_KEY_FLAGS_FRAG_IS_FIRST, FLOWER_IP_FLAGS, "firstfrag" },

};

static int flower_parse_matching_flags(char *str,

				       enum flower_matching_flags type,

				       __u32 *mtf, __u32 *mtf_mask)

{

	char *token;

	bool no;

	bool found;

	int i;

	token = strtok(str, "/");

	while (token) {

		if (!strncmp(token, "no", 2)) {

			no = true;

			token += 2;

		} else

			no = false;

		found = false;

		for (i = 0; i < ARRAY_SIZE(flags_str); i++) {

			if (type != flags_str[i].type)

				continue;

			if (!strcmp(token, flags_str[i].string)) {

				if (no)

					*mtf &= ~flags_str[i].flag;

				else

					*mtf |= flags_str[i].flag;

				*mtf_mask |= flags_str[i].flag;

				found = true;

				break;

			}

		}

		if (!found)

			return -1;

		token = strtok(NULL, "/");

	}

	return 0;

}

static int flower_parse_ip_proto(char *str, __be16 eth_type, int type,

				 __u8 *p_ip_proto, struct nlmsghdr *n)

{

	int ret;

	__u8 ip_proto;

	if (eth_type != htons(ETH_P_IP) && eth_type != htons(ETH_P_IPV6))

		goto err;

	if (matches(str, "tcp") == 0) {

		ip_proto = IPPROTO_TCP;

	} else if (matches(str, "udp") == 0) {

		ip_proto = IPPROTO_UDP;

	} else if (matches(str, "sctp") == 0) {

		ip_proto = IPPROTO_SCTP;

	} else if (matches(str, "icmp") == 0) {

		if (eth_type != htons(ETH_P_IP))

			goto err;

		ip_proto = IPPROTO_ICMP;

	} else if (matches(str, "icmpv6") == 0) {

		if (eth_type != htons(ETH_P_IPV6))

			goto err;

		ip_proto = IPPROTO_ICMPV6;

	} else {

		ret = get_u8(&ip_proto, str, 16);

		if (ret)

			return -1;

	}

	addattr8(n, MAX_MSG, type, ip_proto);

	*p_ip_proto = ip_proto;

	return 0;

err:

	fprintf(stderr, "Illegal \"eth_type\" for ip proto\n");

	return -1;

}

static int __flower_parse_ip_addr(char *str, int family,

				  int addr4_type, int mask4_type,

				  int addr6_type, int mask6_type,

				  struct nlmsghdr *n)

{

	int ret;

	inet_prefix addr;

	int bits;

	int i;

	ret = get_prefix(&addr, str, family);

	if (ret)

		return -1;

	if (family && (addr.family != family)) {

		fprintf(stderr, "Illegal \"eth_type\" for ip address\n");

		return -1;

	}

	addattr_l(n, MAX_MSG, addr.family == AF_INET ? addr4_type : addr6_type,

		  addr.data, addr.bytelen);

	memset(addr.data, 0xff, addr.bytelen);

	bits = addr.bitlen;

	for (i = 0; i < addr.bytelen / 4; i++) {

		if (!bits) {

			addr.data[i] = 0;

		} else if (bits / 32 >= 1) {

			bits -= 32;

		} else {

			addr.data[i] <<= 32 - bits;

			addr.data[i] = htonl(addr.data[i]);

			bits = 0;

		}

	}

	addattr_l(n, MAX_MSG, addr.family == AF_INET ? mask4_type : mask6_type,

		  addr.data, addr.bytelen);

	return 0;

}

static int flower_parse_ip_addr(char *str, __be16 eth_type,

				int addr4_type, int mask4_type,

				int addr6_type, int mask6_type,

				struct nlmsghdr *n)

{

	int family;

	if (eth_type == htons(ETH_P_IP)) {

		family = AF_INET;

	} else if (eth_type == htons(ETH_P_IPV6)) {

		family = AF_INET6;

	} else if (!eth_type) {

		family = AF_UNSPEC;

	} else {

		return -1;

	}

	return __flower_parse_ip_addr(str, family, addr4_type, mask4_type,

				      addr6_type, mask6_type, n);

}

static bool flower_eth_type_arp(__be16 eth_type)

{

	return eth_type == htons(ETH_P_ARP) || eth_type == htons(ETH_P_RARP);

}

static int flower_parse_arp_ip_addr(char *str, __be16 eth_type,

				    int addr_type, int mask_type,

				    struct nlmsghdr *n)

{

	if (!flower_eth_type_arp(eth_type))

		return -1;

	return __flower_parse_ip_addr(str, AF_INET, addr_type, mask_type,

				      TCA_FLOWER_UNSPEC, TCA_FLOWER_UNSPEC, n);

}

static int flower_parse_u8(char *str, int value_type, int mask_type,

			   int (*value_from_name)(const char *str,

						 __u8 *value),

			   bool (*value_validate)(__u8 value),

			   struct nlmsghdr *n)

{

	char *slash;

	int ret, err = -1;

	__u8 value, mask;

	slash = strchr(str, '/');

	if (slash)

		*slash = '\0';

	ret = value_from_name ? value_from_name(str, &value) : -1;

	if (ret < 0) {

		ret = get_u8(&value, str, 10);

		if (ret)

			goto err;

	}

	if (value_validate && !value_validate(value))

		goto err;

	if (slash) {

		ret = get_u8(&mask, slash + 1, 10);

		if (ret)

			goto err;

	}

	else {

		mask = UINT8_MAX;

	}

	addattr8(n, MAX_MSG, value_type, value);

	addattr8(n, MAX_MSG, mask_type, mask);

	err = 0;

err:

	if (slash)

		*slash = '/';

	return err;

}

static const char *flower_print_arp_op_to_name(__u8 op)

{

	switch (op) {

	case ARPOP_REQUEST:

		return "request";

	case ARPOP_REPLY:

		return "reply";

	default:

		return NULL;

	}

}

static int flower_arp_op_from_name(const char *name, __u8 *op)

{

	if (!strcmp(name, "request"))

		*op = ARPOP_REQUEST;

	else if (!strcmp(name, "reply"))

		*op = ARPOP_REPLY;

	else

		return -1;

	return 0;

}

static bool flow_arp_op_validate(__u8 op)

{

	return !op || op == ARPOP_REQUEST || op == ARPOP_REPLY;

}

static int flower_parse_arp_op(char *str, __be16 eth_type,

			       int op_type, int mask_type,

			       struct nlmsghdr *n)

{

	if (!flower_eth_type_arp(eth_type))

		return -1;

	return flower_parse_u8(str, op_type, mask_type, flower_arp_op_from_name,

			       flow_arp_op_validate, n);

}

static int flower_icmp_attr_type(__be16 eth_type, __u8 ip_proto,

				 enum flower_icmp_field field)

{

	if (eth_type == htons(ETH_P_IP) && ip_proto == IPPROTO_ICMP)

		return field == FLOWER_ICMP_FIELD_CODE ?

			TCA_FLOWER_KEY_ICMPV4_CODE :

			TCA_FLOWER_KEY_ICMPV4_TYPE;

	else if (eth_type == htons(ETH_P_IPV6) && ip_proto == IPPROTO_ICMPV6)

		return field == FLOWER_ICMP_FIELD_CODE ?

			TCA_FLOWER_KEY_ICMPV6_CODE :

			TCA_FLOWER_KEY_ICMPV6_TYPE;

	return -1;

}

static int flower_icmp_attr_mask_type(__be16 eth_type, __u8 ip_proto,

				      enum flower_icmp_field field)

{

	if (eth_type == htons(ETH_P_IP) && ip_proto == IPPROTO_ICMP)

		return field == FLOWER_ICMP_FIELD_CODE ?

			TCA_FLOWER_KEY_ICMPV4_CODE_MASK :

			TCA_FLOWER_KEY_ICMPV4_TYPE_MASK;

	else if (eth_type == htons(ETH_P_IPV6) && ip_proto == IPPROTO_ICMPV6)

		return field == FLOWER_ICMP_FIELD_CODE ?

			TCA_FLOWER_KEY_ICMPV6_CODE_MASK :

			TCA_FLOWER_KEY_ICMPV6_TYPE_MASK;

	return -1;

}

static int flower_parse_icmp(char *str, __u16 eth_type, __u8 ip_proto,

			     enum flower_icmp_field field, struct nlmsghdr *n)

{

	int value_type, mask_type;

	value_type = flower_icmp_attr_type(eth_type, ip_proto, field);

	mask_type = flower_icmp_attr_mask_type(eth_type, ip_proto, field);

	if (value_type < 0 || mask_type < 0)

		return -1;

	return flower_parse_u8(str, value_type, mask_type, NULL, NULL, n);

}

static int flower_port_attr_type(__u8 ip_proto, enum flower_endpoint endpoint)

{

	if (ip_proto == IPPROTO_TCP)

		return endpoint == FLOWER_ENDPOINT_SRC ?

			TCA_FLOWER_KEY_TCP_SRC :

			TCA_FLOWER_KEY_TCP_DST;

	else if (ip_proto == IPPROTO_UDP)

		return endpoint == FLOWER_ENDPOINT_SRC ?

			TCA_FLOWER_KEY_UDP_SRC :

			TCA_FLOWER_KEY_UDP_DST;

	else if (ip_proto == IPPROTO_SCTP)

		return endpoint == FLOWER_ENDPOINT_SRC ?

			TCA_FLOWER_KEY_SCTP_SRC :

			TCA_FLOWER_KEY_SCTP_DST;

	else

		return -1;

}

static int flower_port_range_attr_type(__u8 ip_proto, enum flower_endpoint type,

				       __be16 *min_port_type,

				       __be16 *max_port_type)

{

	if (ip_proto == IPPROTO_TCP || ip_proto == IPPROTO_UDP ||

	    ip_proto == IPPROTO_SCTP) {

		if (type == FLOWER_ENDPOINT_SRC) {

			*min_port_type = TCA_FLOWER_KEY_PORT_SRC_MIN;

			*max_port_type = TCA_FLOWER_KEY_PORT_SRC_MAX;

		} else {

			*min_port_type = TCA_FLOWER_KEY_PORT_DST_MIN;

			*max_port_type = TCA_FLOWER_KEY_PORT_DST_MAX;

		}

	} else {

		return -1;

	}

	return 0;

}

/* parse range args in format 10-20 */

static int parse_range(char *str, __be16 *min, __be16 *max)

{

	char *sep;

	sep = strchr(str, '-');

	if (sep) {

		*sep = '\0';

		if (get_be16(min, str, 10))

			return -1;

		if (get_be16(max, sep + 1, 10))

			return -1;

	} else {

		if (get_be16(min, str, 10))

			return -1;

	}

	return 0;

}

static int flower_parse_port(char *str, __u8 ip_proto,

			     enum flower_endpoint endpoint,

			     struct nlmsghdr *n)

{

	__be16 min = 0;

	__be16 max = 0;

	int ret;

	ret = parse_range(str, &min, &max;;

	if (ret)

		return -1;

	if (min && max) {

		__be16 min_port_type, max_port_type;

		if (max <= min) {

			fprintf(stderr, "max value should be greater than min value\n");

			return -1;

		}

		if (flower_port_range_attr_type(ip_proto, endpoint,

						&min_port_type, &max_port_type))

			return -1;

		addattr16(n, MAX_MSG, min_port_type, min);

		addattr16(n, MAX_MSG, max_port_type, max);

	} else if (min && !max) {

		int type;

		type = flower_port_attr_type(ip_proto, endpoint);

		if (type < 0)

			return -1;

		addattr16(n, MAX_MSG, type, min);

	} else {

		return -1;

	}

	return 0;

}

#define TCP_FLAGS_MAX_MASK 0xfff

static int flower_parse_tcp_flags(char *str, int flags_type, int mask_type,

				  struct nlmsghdr *n)

{

	char *slash;

	int ret, err = -1;

	__u16 flags;

	slash = strchr(str, '/');

	if (slash)

		*slash = '\0';

	ret = get_u16(&flags, str, 16);

	if (ret < 0 || flags & ~TCP_FLAGS_MAX_MASK)

		goto err;

	addattr16(n, MAX_MSG, flags_type, htons(flags));

	if (slash) {

		ret = get_u16(&flags, slash + 1, 16);

		if (ret < 0 || flags & ~TCP_FLAGS_MAX_MASK)

			goto err;

	} else {

		flags = TCP_FLAGS_MAX_MASK;

	}

	addattr16(n, MAX_MSG, mask_type, htons(flags));

	err = 0;

err:

	if (slash)

		*slash = '/';

	return err;

}

static int flower_parse_ip_tos_ttl(char *str, int key_type, int mask_type,

				   struct nlmsghdr *n)

{

	char *slash;

	int ret, err = -1;

	__u8 tos_ttl;

	slash = strchr(str, '/');

	if (slash)

		*slash = '\0';

	ret = get_u8(&tos_ttl, str, 10);

	if (ret < 0)

		ret = get_u8(&tos_ttl, str, 16);

	if (ret < 0)

		goto err;

	addattr8(n, MAX_MSG, key_type, tos_ttl);

	if (slash) {

		ret = get_u8(&tos_ttl, slash + 1, 16);

		if (ret < 0)

			goto err;

	} else {

		tos_ttl = 0xff;

	}

	addattr8(n, MAX_MSG, mask_type, tos_ttl);

	err = 0;

err:

	if (slash)

		*slash = '/';

	return err;

}

static int flower_parse_key_id(const char *str, int type, struct nlmsghdr *n)

{

	int ret;

	__be32 key_id;

	ret = get_be32(&key_id, str, 10);

	if (!ret)

		addattr32(n, MAX_MSG, type, key_id);

	return ret;

}

static int flower_parse_enc_port(char *str, int type, struct nlmsghdr *n)

{

	int ret;

	__be16 port;

	ret = get_be16(&port, str, 10);

	if (ret)

		return -1;

	addattr16(n, MAX_MSG, type, port);

	return 0;

}

static int flower_parse_geneve_opts(char *str, struct nlmsghdr *n)

{

	struct rtattr *nest;

	char *token;

	int i, err;

	nest = addattr_nest(n, MAX_MSG, TCA_FLOWER_KEY_ENC_OPTS_GENEVE);

	i = 1;

	token = strsep(&str, ":");

	while (token) {

		switch (i) {

		case TCA_FLOWER_KEY_ENC_OPT_GENEVE_CLASS:

		{

			__be16 opt_class;

			if (!strlen(token))

				break;

			err = get_be16(&opt_class, token, 16);

			if (err)

				return err;

			addattr16(n, MAX_MSG, i, opt_class);

			break;

		}

		case TCA_FLOWER_KEY_ENC_OPT_GENEVE_TYPE:

		{

			__u8 opt_type;

			if (!strlen(token))

				break;

			err = get_u8(&opt_type, token, 16);

			if (err)

				return err;

			addattr8(n, MAX_MSG, i, opt_type);

			break;

		}

		case TCA_FLOWER_KEY_ENC_OPT_GENEVE_DATA:

		{

			size_t token_len = strlen(token);

			__u8 *opts;

			if (!token_len)

				break;

			opts = malloc(token_len / 2);

			if (!opts)

				return -1;

			if (hex2mem(token, opts, token_len / 2) < 0) {

				free(opts);

				return -1;

			}

			addattr_l(n, MAX_MSG, i, opts, token_len / 2);

			free(opts);

			break;

		}

		default:

			fprintf(stderr, "Unknown \"geneve_opts\" type\n");

			return -1;

		}

		token = strsep(&str, ":");

		i++;

	}

	addattr_nest_end(n, nest);

	return 0;

}

static int flower_parse_enc_opt_part(char *str, struct nlmsghdr *n)

{

	char *token;

	int err;

	token = strsep(&str, ",");

	while (token) {

		err = flower_parse_geneve_opts(token, n);

		if (err)

			return err;

		token = strsep(&str, ",");

	}

	return 0;

}

static int flower_check_enc_opt_key(char *key)

{

	int key_len, col_cnt = 0;

	key_len = strlen(key);

	while ((key = strchr(key, ':'))) {

		if (strlen(key) == key_len)

			return -1;

		key_len = strlen(key) - 1;

		col_cnt++;

		key++;

	}

	if (col_cnt != 2 || !key_len)

		return -1;

	return 0;

}

static int flower_parse_enc_opts(char *str, struct nlmsghdr *n)

{

	char key[XATTR_SIZE_MAX], mask[XATTR_SIZE_MAX];

	int data_len, key_len, mask_len, err;

	char *token, *slash;

	struct rtattr *nest;

	key_len = 0;

	mask_len = 0;

	token = strsep(&str, ",");

	while (token) {

		slash = strchr(token, '/');

		if (slash)

			*slash = '\0';

		if ((key_len + strlen(token) > XATTR_SIZE_MAX) ||

		    flower_check_enc_opt_key(token))

			return -1;

		strcpy(&key[key_len], token);

		key_len += strlen(token) + 1;

		key[key_len - 1] = ',';

		if (!slash) {

			/* Pad out mask when not provided */

			if (mask_len + strlen(token) > XATTR_SIZE_MAX)

				return -1;

			data_len = strlen(rindex(token, ':'));

			sprintf(&mask[mask_len], "ffff:ff:");

			mask_len += 8;

			memset(&mask[mask_len], 'f', data_len - 1);

			mask_len += data_len;

			mask[mask_len - 1] = ',';

			token = strsep(&str, ",");

			continue;

		}

		if (mask_len + strlen(slash + 1) > XATTR_SIZE_MAX)

			return -1;

		strcpy(&mask[mask_len], slash + 1);

		mask_len += strlen(slash + 1) + 1;

		mask[mask_len - 1] = ',';

		*slash = '/';

		token = strsep(&str, ",");

	}

	key[key_len - 1] = '\0';

	mask[mask_len - 1] = '\0';

	nest = addattr_nest(n, MAX_MSG, TCA_FLOWER_KEY_ENC_OPTS);

	err = flower_parse_enc_opt_part(key, n);

	if (err)

		return err;

	addattr_nest_end(n, nest);

	nest = addattr_nest(n, MAX_MSG, TCA_FLOWER_KEY_ENC_OPTS_MASK);

	err = flower_parse_enc_opt_part(mask, n);

	if (err)

		return err;

	addattr_nest_end(n, nest);

	return 0;

}

static int flower_parse_opt(struct filter_util *qu, char *handle,

			    int argc, char **argv, struct nlmsghdr *n)

{

	int ret;

	struct tcmsg *t = NLMSG_DATA(n);

	struct rtattr *tail;

	__be16 eth_type = TC_H_MIN(t->tcm_info);

	__be16 vlan_ethtype = 0;

	__be16 cvlan_ethtype = 0;

	__u8 ip_proto = 0xff;

	__u32 flags = 0;

	__u32 mtf = 0;

	__u32 mtf_mask = 0;

	if (handle) {

		ret = get_u32(&t->tcm_handle, handle, 0);

		if (ret) {

			fprintf(stderr, "Illegal \"handle\"\n");

			return -1;

		}

	}

	tail = (struct rtattr *) (((void *) n) + NLMSG_ALIGN(n->nlmsg_len));

	addattr_l(n, MAX_MSG, TCA_OPTIONS, NULL, 0);

	if (argc == 0) {

		/*at minimal we will match all ethertype packets */

		goto parse_done;

	}

	while (argc > 0) {

		if (matches(*argv, "classid") == 0 ||

		    matches(*argv, "flowid") == 0) {

			unsigned int handle;

			NEXT_ARG();

			ret = get_tc_classid(&handle, *argv);

			if (ret) {

				fprintf(stderr, "Illegal \"classid\"\n");

				return -1;

			}

			addattr_l(n, MAX_MSG, TCA_FLOWER_CLASSID, &handle, 4);

		} else if (matches(*argv, "hw_tc") == 0) {

			unsigned int handle;

			__u32 tc;

			char *end;

			NEXT_ARG();

			tc = strtoul(*argv, &end, 0);

			if (*end) {

				fprintf(stderr, "Illegal TC index\n");

				return -1;

			}

			if (tc >= TC_QOPT_MAX_QUEUE) {

				fprintf(stderr, "TC index exceeds max range\n");

				return -1;

			}