[mirror_iproute2.git] / tc / em_cmp.c

/*
 * em_cmp.c		Simle coparison Ematch
 *
 *		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:	Thomas Graf <tgraf@suug.ch>
 */

#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 <dlfcn.h>
#include <errno.h>

#include "m_ematch.h"
#include <linux/tc_ematch/tc_em_cmp.h>

extern struct ematch_util cmp_ematch_util;

static void cmp_print_usage(FILE *fd)
{
	fprintf(fd,
	    "Usage: cmp(ALIGN at OFFSET [ ATTRS ] { eq | lt | gt } VALUE)\n" \
	    "where: ALIGN  := { u8 | u16 | u32 }\n" \
	    "       ATTRS  := [ layer LAYER ] [ mask MASK ] [ trans ]\n" \
	    "       LAYER  := { link | header | next-header | 0..%d }\n" \
	    "\n" \
	    "Example: cmp(u16 at 3 layer 2 mask 0xff00 gt 20)\n",
	    TCF_LAYER_MAX);
}

static int cmp_parse_eopt(struct nlmsghdr *n, struct tcf_ematch_hdr *hdr,
			  struct bstr *args)
{
	struct bstr *a;
	int align, opnd = 0;
	unsigned long offset = 0, layer = TCF_LAYER_NETWORK, mask = 0, value = 0;
	int offset_present = 0, value_present = 0;
	struct tcf_em_cmp cmp;

	memset(&cmp, 0, sizeof(cmp));

#define PARSE_ERR(CARG, FMT, ARGS...) \
	em_parse_error(EINVAL, args, CARG, &cmp_ematch_util, FMT ,##ARGS)

	if (args == NULL)
		return PARSE_ERR(args, "cmp: missing arguments");

	if (!bstrcmp(args, "u8"))
		align = TCF_EM_ALIGN_U8;
	else if (!bstrcmp(args, "u16"))
		align = TCF_EM_ALIGN_U16;
	else if (!bstrcmp(args, "u32"))
		align = TCF_EM_ALIGN_U32;
	else
		return PARSE_ERR(args, "cmp: invalid alignment");

	for (a = bstr_next(args); a; a = bstr_next(a)) {
		if (!bstrcmp(a, "at")) {
			if (a->next == NULL)
				return PARSE_ERR(a, "cmp: missing argument");
			a = bstr_next(a);

			offset = bstrtoul(a);
			if (offset == ULONG_MAX)
				return PARSE_ERR(a, "cmp: invalid offset, " \
				    "must be numeric");

			offset_present = 1;
		} else if (!bstrcmp(a, "layer")) {
			if (a->next == NULL)
				return PARSE_ERR(a, "cmp: missing argument");
			a = bstr_next(a);

			layer = parse_layer(a);
			if (layer == INT_MAX) {
				layer = bstrtoul(a);
				if (layer == ULONG_MAX)
					return PARSE_ERR(a, "cmp: invalid " \
					    "layer");
			}

			if (layer > TCF_LAYER_MAX)
				return PARSE_ERR(a, "cmp: illegal layer, " \
				    "must be in 0..%d", TCF_LAYER_MAX);
		} else if (!bstrcmp(a, "mask")) {
			if (a->next == NULL)
				return PARSE_ERR(a, "cmp: missing argument");
			a = bstr_next(a);

			mask = bstrtoul(a);
			if (mask == ULONG_MAX)
				return PARSE_ERR(a, "cmp: invalid mask");
		} else if (!bstrcmp(a, "trans")) {
			cmp.flags |= TCF_EM_CMP_TRANS;
		} else if (!bstrcmp(a, "eq") || !bstrcmp(a, "gt") ||
		    !bstrcmp(a, "lt")) {

			if (!bstrcmp(a, "eq"))
				opnd = TCF_EM_OPND_EQ;
			else if (!bstrcmp(a, "gt"))
				opnd = TCF_EM_OPND_GT;
			else if (!bstrcmp(a, "lt"))
				opnd = TCF_EM_OPND_LT;

			if (a->next == NULL)
				return PARSE_ERR(a, "cmp: missing argument");
			a = bstr_next(a);

			value = bstrtoul(a);
			if (value == ULONG_MAX)
				return PARSE_ERR(a, "cmp: invalid value");

			value_present = 1;
		} else
			return PARSE_ERR(a, "nbyte: unknown parameter");
	}

	if (offset_present == 0 || value_present == 0)
		return PARSE_ERR(a, "cmp: offset and value required");

	cmp.val = (__u32) value;
	cmp.mask = (__u32) mask;
	cmp.off = (__u16) offset;
	cmp.align = (__u8) align;
	cmp.layer = (__u8) layer;
	cmp.opnd = (__u8) opnd;

	addraw_l(n, MAX_MSG, hdr, sizeof(*hdr));
	addraw_l(n, MAX_MSG, &cmp, sizeof(cmp));

#undef PARSE_ERR
	return 0;
}

static int cmp_print_eopt(FILE *fd, struct tcf_ematch_hdr *hdr, void *data,
			  int data_len)
{
	struct tcf_em_cmp *cmp = data;

	if (data_len < sizeof(*cmp)) {
		fprintf(stderr, "CMP header size mismatch\n");
		return -1;
	}

	if (cmp->align == TCF_EM_ALIGN_U8)
		fprintf(fd, "u8 ");
	else if (cmp->align == TCF_EM_ALIGN_U16)
		fprintf(fd, "u16 ");
	else if (cmp->align == TCF_EM_ALIGN_U16)
		fprintf(fd, "u32 ");

	fprintf(fd, "at %d layer %d ", cmp->off, cmp->layer);

	if (cmp->mask)
		fprintf(fd, "mask 0x%x ", cmp->mask);

	if (cmp->flags & TCF_EM_CMP_TRANS)
		fprintf(fd, "trans ");

	if (cmp->opnd == TCF_EM_OPND_EQ)
		fprintf(fd, "eq ");
	else if (cmp->opnd == TCF_EM_OPND_LT)
		fprintf(fd, "lt ");
	else if (cmp->opnd == TCF_EM_OPND_GT)
		fprintf(fd, "gt ");

	fprintf(fd, "%d", cmp->val);

	return 0;
}

struct ematch_util cmp_ematch_util = {
	.kind = "cmp",
	.kind_num = TCF_EM_CMP,
	.parse_eopt = cmp_parse_eopt,
	.print_eopt = cmp_print_eopt,
	.print_usage = cmp_print_usage
};
Commit	Line	Data
311b4145 SH	1	/*
	2	* em_cmp.c Simle coparison Ematch
	3	*
	4	* This program is free software; you can distribute 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: Thomas Graf <tgraf@suug.ch>
	10	*/
	11
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <unistd.h>
	15	#include <syslog.h>
	16	#include <fcntl.h>
	17	#include <sys/socket.h>
	18	#include <netinet/in.h>
	19	#include <arpa/inet.h>
	20	#include <string.h>
	21	#include <dlfcn.h>
	22	#include <errno.h>
	23
	24	#include "m_ematch.h"
	25	#include <linux/tc_ematch/tc_em_cmp.h>
	26
	27	extern struct ematch_util cmp_ematch_util;
	28
	29	static void cmp_print_usage(FILE *fd)
	30	{
	31	fprintf(fd,
	32	"Usage: cmp(ALIGN at OFFSET [ ATTRS ] { eq \| lt \| gt } VALUE)\n" \
	33	"where: ALIGN := { u8 \| u16 \| u32 }\n" \
	34	" ATTRS := [ layer LAYER ] [ mask MASK ] [ trans ]\n" \
	35	" LAYER := { link \| header \| next-header \| 0..%d }\n" \
	36	"\n" \
	37	"Example: cmp(u16 at 3 layer 2 mask 0xff00 gt 20)\n",
	38	TCF_LAYER_MAX);
	39	}
	40
	41	static int cmp_parse_eopt(struct nlmsghdr n, struct tcf_ematch_hdr hdr,
	42	struct bstr *args)
	43	{
	44	struct bstr *a;
	45	int align, opnd = 0;
	46	unsigned long offset = 0, layer = TCF_LAYER_NETWORK, mask = 0, value = 0;
	47	int offset_present = 0, value_present = 0;
	48	struct tcf_em_cmp cmp;
	49
	50	memset(&cmp, 0, sizeof(cmp));
	51
	52	#define PARSE_ERR(CARG, FMT, ARGS...) \
	53	em_parse_error(EINVAL, args, CARG, &cmp_ematch_util, FMT ,##ARGS)
	54
	55	if (args == NULL)
	56	return PARSE_ERR(args, "cmp: missing arguments");
	57
	58	if (!bstrcmp(args, "u8"))
	59	align = TCF_EM_ALIGN_U8;
	60	else if (!bstrcmp(args, "u16"))
	61	align = TCF_EM_ALIGN_U16;
	62	else if (!bstrcmp(args, "u32"))
	63	align = TCF_EM_ALIGN_U32;
	64	else
65	return PARSE_ERR(args, "cmp: invalid alignment");
ae665a52	66
311b4145 SH	67	for (a = bstr_next(args); a; a = bstr_next(a)) {
	68	if (!bstrcmp(a, "at")) {
	69	if (a->next == NULL)
	70	return PARSE_ERR(a, "cmp: missing argument");
	71	a = bstr_next(a);
	72
	73	offset = bstrtoul(a);
	74	if (offset == ULONG_MAX)
	75	return PARSE_ERR(a, "cmp: invalid offset, " \
	76	"must be numeric");
	77
	78	offset_present = 1;
	79	} else if (!bstrcmp(a, "layer")) {
	80	if (a->next == NULL)
	81	return PARSE_ERR(a, "cmp: missing argument");
	82	a = bstr_next(a);
	83
	84	layer = parse_layer(a);
	85	if (layer == INT_MAX) {
	86	layer = bstrtoul(a);
	87	if (layer == ULONG_MAX)
	88	return PARSE_ERR(a, "cmp: invalid " \
	89	"layer");
	90	}
	91
	92	if (layer > TCF_LAYER_MAX)
	93	return PARSE_ERR(a, "cmp: illegal layer, " \
	94	"must be in 0..%d", TCF_LAYER_MAX);
	95	} else if (!bstrcmp(a, "mask")) {
	96	if (a->next == NULL)
	97	return PARSE_ERR(a, "cmp: missing argument");
	98	a = bstr_next(a);
	99
	100	mask = bstrtoul(a);
	101	if (mask == ULONG_MAX)
	102	return PARSE_ERR(a, "cmp: invalid mask");
	103	} else if (!bstrcmp(a, "trans")) {
	104	cmp.flags \|= TCF_EM_CMP_TRANS;
	105	} else if (!bstrcmp(a, "eq") \|\| !bstrcmp(a, "gt") \|\|
	106	!bstrcmp(a, "lt")) {
	107
	108	if (!bstrcmp(a, "eq"))
	109	opnd = TCF_EM_OPND_EQ;
	110	else if (!bstrcmp(a, "gt"))
	111	opnd = TCF_EM_OPND_GT;
	112	else if (!bstrcmp(a, "lt"))
	113	opnd = TCF_EM_OPND_LT;
ae665a52	114
311b4145 SH	115	if (a->next == NULL)
	116	return PARSE_ERR(a, "cmp: missing argument");
	117	a = bstr_next(a);
	118
	119	value = bstrtoul(a);
	120	if (value == ULONG_MAX)
	121	return PARSE_ERR(a, "cmp: invalid value");
	122
	123	value_present = 1;
	124	} else
	125	return PARSE_ERR(a, "nbyte: unknown parameter");
	126	}
	127
	128	if (offset_present == 0 \|\| value_present == 0)
	129	return PARSE_ERR(a, "cmp: offset and value required");
	130
	131	cmp.val = (__u32) value;
	132	cmp.mask = (__u32) mask;
	133	cmp.off = (__u16) offset;
	134	cmp.align = (__u8) align;
	135	cmp.layer = (__u8) layer;
	136	cmp.opnd = (__u8) opnd;
	137
	138	addraw_l(n, MAX_MSG, hdr, sizeof(*hdr));
	139	addraw_l(n, MAX_MSG, &cmp, sizeof(cmp));
	140
	141	#undef PARSE_ERR
	142	return 0;
	143	}
	144
	145	static int cmp_print_eopt(FILE fd, struct tcf_ematch_hdr hdr, void *data,
	146	int data_len)
	147	{
	148	struct tcf_em_cmp *cmp = data;
	149
	150	if (data_len < sizeof(*cmp)) {
	151	fprintf(stderr, "CMP header size mismatch\n");
	152	return -1;
	153	}
	154
	155	if (cmp->align == TCF_EM_ALIGN_U8)
	156	fprintf(fd, "u8 ");
	157	else if (cmp->align == TCF_EM_ALIGN_U16)
	158	fprintf(fd, "u16 ");
	159	else if (cmp->align == TCF_EM_ALIGN_U16)
	160	fprintf(fd, "u32 ");
	161
	162	fprintf(fd, "at %d layer %d ", cmp->off, cmp->layer);
	163
	164	if (cmp->mask)
	165	fprintf(fd, "mask 0x%x ", cmp->mask);
	166
	167	if (cmp->flags & TCF_EM_CMP_TRANS)
	168	fprintf(fd, "trans ");
	169
	170	if (cmp->opnd == TCF_EM_OPND_EQ)
	171	fprintf(fd, "eq ");
	172	else if (cmp->opnd == TCF_EM_OPND_LT)
	173	fprintf(fd, "lt ");
	174	else if (cmp->opnd == TCF_EM_OPND_GT)
	175	fprintf(fd, "gt ");
	176
	177	fprintf(fd, "%d", cmp->val);
	178
179	return 0;
180	}
181
182	struct ematch_util cmp_ematch_util = {
183	.kind = "cmp",
184	.kind_num = TCF_EM_CMP,
185	.parse_eopt = cmp_parse_eopt,
186	.print_eopt = cmp_print_eopt,
187	.print_usage = cmp_print_usage
188	};