Adding upstream version 6.1.0.upstream/6.1.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 569 insertions, 0 deletions

diff --git a/tc/m_ematch.c b/tc/m_ematch.c
new file mode 100644
index 0000000..8840a0d
--- /dev/null
+++ b/tc/m_ematch.c
@@ -0,0 +1,569 @@
+/*
+ * m_ematch.c		Extended Matches
+ *
+ *		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 <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <dlfcn.h>
+#include <stdarg.h>
+#include <errno.h>
+
+#include "utils.h"
+#include "tc_util.h"
+#include "m_ematch.h"
+
+#define EMATCH_MAP "/etc/iproute2/ematch_map"
+
+static struct ematch_util *ematch_list;
+
+/* export to bison parser */
+int ematch_argc;
+char **ematch_argv;
+char *ematch_err;
+struct ematch *ematch_root;
+
+static int begin_argc;
+static char **begin_argv;
+
+static void bstr_print(FILE *fd, const struct bstr *b, int ascii);
+
+static inline void map_warning(int num, char *kind)
+{
+	fprintf(stderr,
+	    "Error: Unable to find ematch \"%s\" in %s\n" \
+	    "Please assign a unique ID to the ematch kind the suggested " \
+	    "entry is:\n" \
+	    "\t%d\t%s\n",
+	    kind, EMATCH_MAP, num, kind);
+}
+
+static int lookup_map(__u16 num, char *dst, int len, const char *file)
+{
+	int err = -EINVAL;
+	char buf[512];
+	FILE *fd = fopen(file, "r");
+
+	if (fd == NULL)
+		return -errno;
+
+	while (fgets(buf, sizeof(buf), fd)) {
+		char namebuf[512], *p = buf;
+		int id;
+
+		while (*p == ' ' || *p == '\t')
+			p++;
+		if (*p == '#' || *p == '\n' || *p == 0)
+			continue;
+
+		if (sscanf(p, "%d %s", &id, namebuf) != 2) {
+			fprintf(stderr, "ematch map %s corrupted at %s\n",
+			    file, p);
+			goto out;
+		}
+
+		if (id == num) {
+			if (dst)
+				strncpy(dst, namebuf, len - 1);
+			err = 0;
+			goto out;
+		}
+	}
+
+	err = -ENOENT;
+out:
+	fclose(fd);
+	return err;
+}
+
+static int lookup_map_id(char *kind, int *dst, const char *file)
+{
+	int err = -EINVAL;
+	char buf[512];
+	FILE *fd = fopen(file, "r");
+
+	if (fd == NULL)
+		return -errno;
+
+	while (fgets(buf, sizeof(buf), fd)) {
+		char namebuf[512], *p = buf;
+		int id;
+
+		while (*p == ' ' || *p == '\t')
+			p++;
+		if (*p == '#' || *p == '\n' || *p == 0)
+			continue;
+
+		if (sscanf(p, "%d %s", &id, namebuf) != 2) {
+			fprintf(stderr, "ematch map %s corrupted at %s\n",
+			    file, p);
+			goto out;
+		}
+
+		if (!strcasecmp(namebuf, kind)) {
+			if (dst)
+				*dst = id;
+			err = 0;
+			goto out;
+		}
+	}
+
+	err = -ENOENT;
+	*dst = 0;
+out:
+	fclose(fd);
+	return err;
+}
+
+static struct ematch_util *get_ematch_kind(char *kind)
+{
+	static void *body;
+	void *dlh;
+	char buf[256];
+	struct ematch_util *e;
+
+	for (e = ematch_list; e; e = e->next) {
+		if (strcmp(e->kind, kind) == 0)
+			return e;
+	}
+
+	snprintf(buf, sizeof(buf), "em_%s.so", kind);
+	dlh = dlopen(buf, RTLD_LAZY);
+	if (dlh == NULL) {
+		dlh = body;
+		if (dlh == NULL) {
+			dlh = body = dlopen(NULL, RTLD_LAZY);
+			if (dlh == NULL)
+				return NULL;
+		}
+	}
+
+	snprintf(buf, sizeof(buf), "%s_ematch_util", kind);
+	e = dlsym(dlh, buf);
+	if (e == NULL)
+		return NULL;
+
+	e->next = ematch_list;
+	ematch_list = e;
+
+	return e;
+}
+
+static struct ematch_util *get_ematch_kind_num(__u16 kind)
+{
+	char name[513];
+
+	if (lookup_map(kind, name, sizeof(name), EMATCH_MAP) < 0)
+		return NULL;
+
+	return get_ematch_kind(name);
+}
+
+static int em_parse_call(struct nlmsghdr *n, struct tcf_ematch_hdr *hdr,
+			 struct ematch_util *e, struct ematch *t)
+{
+	if (e->parse_eopt_argv) {
+		int argc = 0, i = 0, ret;
+		struct bstr *args;
+		char **argv;
+
+		for (args = t->args; args; args = bstr_next(args))
+			argc++;
+		argv = calloc(argc, sizeof(char *));
+		if (!argv)
+			return -1;
+		for (args = t->args; args; args = bstr_next(args))
+			argv[i++] = args->data;
+
+		ret = e->parse_eopt_argv(n, hdr, argc, argv);
+
+		free(argv);
+		return ret;
+	}
+
+	return e->parse_eopt(n, hdr, t->args->next);
+}
+
+static int parse_tree(struct nlmsghdr *n, struct ematch *tree)
+{
+	int index = 1;
+	struct ematch *t;
+
+	for (t = tree; t; t = t->next) {
+		struct rtattr *tail;
+		struct tcf_ematch_hdr hdr = { .flags = t->relation };
+
+		if (t->inverted)
+			hdr.flags |= TCF_EM_INVERT;
+
+		tail = addattr_nest(n, MAX_MSG, index++);
+
+		if (t->child) {
+			__u32 r = t->child_ref;
+
+			addraw_l(n, MAX_MSG, &hdr, sizeof(hdr));
+			addraw_l(n, MAX_MSG, &r, sizeof(r));
+		} else {
+			int num = 0, err;
+			char buf[64];
+			struct ematch_util *e;
+
+			if (t->args == NULL)
+				return -1;
+
+			strncpy(buf, (char *) t->args->data, sizeof(buf)-1);
+			e = get_ematch_kind(buf);
+			if (e == NULL) {
+				fprintf(stderr, "Unknown ematch \"%s\"\n",
+				    buf);
+				return -1;
+			}
+
+			err = lookup_map_id(buf, &num, EMATCH_MAP);
+			if (err < 0) {
+				if (err == -ENOENT)
+					map_warning(e->kind_num, buf);
+				return err;
+			}
+
+			hdr.kind = num;
+			if (em_parse_call(n, &hdr, e, t) < 0)
+				return -1;
+		}
+
+		addattr_nest_end(n, tail);
+	}
+
+	return 0;
+}
+
+static int flatten_tree(struct ematch *head, struct ematch *tree)
+{
+	int i, count = 0;
+	struct ematch *t;
+
+	for (;;) {
+		count++;
+
+		if (tree->child) {
+			for (t = head; t->next; t = t->next);
+			t->next = tree->child;
+			count += flatten_tree(head, tree->child);
+		}
+
+		if (tree->relation == 0)
+			break;
+
+		tree = tree->next;
+	}
+
+	for (i = 0, t = head; t; t = t->next, i++)
+		t->index = i;
+
+	for (t = head; t; t = t->next)
+		if (t->child)
+			t->child_ref = t->child->index;
+
+	return count;
+}
+
+__attribute__((format(printf, 5, 6)))
+int em_parse_error(int err, struct bstr *args, struct bstr *carg,
+		   struct ematch_util *e, char *fmt, ...)
+{
+	va_list a;
+
+	va_start(a, fmt);
+	vfprintf(stderr, fmt, a);
+	va_end(a);
+
+	if (ematch_err)
+		fprintf(stderr, ": %s\n... ", ematch_err);
+	else
+		fprintf(stderr, "\n... ");
+
+	while (ematch_argc < begin_argc) {
+		if (ematch_argc == (begin_argc - 1))
+			fprintf(stderr, ">>%s<< ", *begin_argv);
+		else
+			fprintf(stderr, "%s ", *begin_argv);
+		begin_argv++;
+		begin_argc--;
+	}
+
+	fprintf(stderr, "...\n");
+
+	if (args) {
+		fprintf(stderr, "... %s(", e->kind);
+		while (args) {
+			fprintf(stderr, "%s", args == carg ? ">>" : "");
+			bstr_print(stderr, args, 1);
+			fprintf(stderr, "%s%s", args == carg ? "<<" : "",
+			    args->next ? " " : "");
+			args = args->next;
+		}
+		fprintf(stderr, ")...\n");
+
+	}
+
+	if (e == NULL) {
+		fprintf(stderr,
+		    "Usage: EXPR\n" \
+		    "where: EXPR  := TERM [ { and | or } EXPR ]\n" \
+		    "       TERM  := [ not ] { MATCH | '(' EXPR ')' }\n" \
+		    "       MATCH := module '(' ARGS ')'\n" \
+		    "       ARGS := ARG1 ARG2 ...\n" \
+		    "\n" \
+		    "Example: a(x y) and not (b(x) or c(x y z))\n");
+	} else
+		e->print_usage(stderr);
+
+	return -err;
+}
+
+static inline void free_ematch_err(void)
+{
+	if (ematch_err) {
+		free(ematch_err);
+		ematch_err = NULL;
+	}
+}
+
+extern int ematch_parse(void);
+
+int parse_ematch(int *argc_p, char ***argv_p, int tca_id, struct nlmsghdr *n)
+{
+	begin_argc = ematch_argc = *argc_p;
+	begin_argv = ematch_argv = *argv_p;
+
+	if (ematch_parse()) {
+		int err = em_parse_error(EINVAL, NULL, NULL, NULL,
+		    "Parse error");
+		free_ematch_err();
+		return err;
+	}
+
+	free_ematch_err();
+
+	/* undo look ahead by parser */
+	ematch_argc++;
+	ematch_argv--;
+
+	if (ematch_root) {
+		struct rtattr *tail, *tail_list;
+
+		struct tcf_ematch_tree_hdr hdr = {
+			.nmatches = flatten_tree(ematch_root, ematch_root),
+			.progid = TCF_EM_PROG_TC
+		};
+
+		tail = addattr_nest(n, MAX_MSG, tca_id);
+		addattr_l(n, MAX_MSG, TCA_EMATCH_TREE_HDR, &hdr, sizeof(hdr));
+
+		tail_list = addattr_nest(n, MAX_MSG, TCA_EMATCH_TREE_LIST);
+
+		if (parse_tree(n, ematch_root) < 0)
+			return -1;
+
+		addattr_nest_end(n, tail_list);
+		addattr_nest_end(n, tail);
+	}
+
+	*argc_p = ematch_argc;
+	*argv_p = ematch_argv;
+
+	return 0;
+}
+
+static int print_ematch_seq(FILE *fd, struct rtattr **tb, int start,
+			    int prefix)
+{
+	int n, i = start;
+	struct tcf_ematch_hdr *hdr;
+	int dlen;
+	void *data;
+
+	for (;;) {
+		if (tb[i] == NULL)
+			return -1;
+
+		dlen = RTA_PAYLOAD(tb[i]) - sizeof(*hdr);
+		data = (void *) RTA_DATA(tb[i]) + sizeof(*hdr);
+
+		if (dlen < 0)
+			return -1;
+
+		hdr = RTA_DATA(tb[i]);
+
+		if (hdr->flags & TCF_EM_INVERT)
+			fprintf(fd, "NOT ");
+
+		if (hdr->kind == 0) {
+			__u32 ref;
+
+			if (dlen < sizeof(__u32))
+				return -1;
+
+			ref = *(__u32 *) data;
+			fprintf(fd, "(\n");
+			for (n = 0; n <= prefix; n++)
+				fprintf(fd, "  ");
+			if (print_ematch_seq(fd, tb, ref + 1, prefix + 1) < 0)
+				return -1;
+			for (n = 0; n < prefix; n++)
+				fprintf(fd, "  ");
+			fprintf(fd, ") ");
+
+		} else {
+			struct ematch_util *e;
+
+			e = get_ematch_kind_num(hdr->kind);
+			if (e == NULL)
+				fprintf(fd, "[unknown ematch %d]\n",
+				    hdr->kind);
+			else {
+				fprintf(fd, "%s(", e->kind);
+				if (e->print_eopt(fd, hdr, data, dlen) < 0)
+					return -1;
+				fprintf(fd, ")\n");
+			}
+			if (hdr->flags & TCF_EM_REL_MASK)
+				for (n = 0; n < prefix; n++)
+					fprintf(fd, "  ");
+		}
+
+		switch (hdr->flags & TCF_EM_REL_MASK) {
+			case TCF_EM_REL_AND:
+				fprintf(fd, "AND ");
+				break;
+
+			case TCF_EM_REL_OR:
+				fprintf(fd, "OR ");
+				break;
+
+			default:
+				return 0;
+		}
+
+		i++;
+	}
+
+	return 0;
+}
+
+static int print_ematch_list(FILE *fd, struct tcf_ematch_tree_hdr *hdr,
+			     struct rtattr *rta)
+{
+	int err = -1;
+	struct rtattr **tb;
+
+	tb = malloc((hdr->nmatches + 1) * sizeof(struct rtattr *));
+	if (tb == NULL)
+		return -1;
+
+	if (hdr->nmatches > 0) {
+		if (parse_rtattr_nested(tb, hdr->nmatches, rta) < 0)
+			goto errout;
+
+		fprintf(fd, "\n  ");
+		if (print_ematch_seq(fd, tb, 1, 1) < 0)
+			goto errout;
+	}
+
+	err = 0;
+errout:
+	free(tb);
+	return err;
+}
+
+int print_ematch(FILE *fd, const struct rtattr *rta)
+{
+	struct rtattr *tb[TCA_EMATCH_TREE_MAX+1];
+	struct tcf_ematch_tree_hdr *hdr;
+
+	if (parse_rtattr_nested(tb, TCA_EMATCH_TREE_MAX, rta) < 0)
+		return -1;
+
+	if (tb[TCA_EMATCH_TREE_HDR] == NULL) {
+		fprintf(stderr, "Missing ematch tree header\n");
+		return -1;
+	}
+
+	if (tb[TCA_EMATCH_TREE_LIST] == NULL) {
+		fprintf(stderr, "Missing ematch tree list\n");
+		return -1;
+	}
+
+	if (RTA_PAYLOAD(tb[TCA_EMATCH_TREE_HDR]) < sizeof(*hdr)) {
+		fprintf(stderr, "Ematch tree header size mismatch\n");
+		return -1;
+	}
+
+	hdr = RTA_DATA(tb[TCA_EMATCH_TREE_HDR]);
+
+	return print_ematch_list(fd, hdr, tb[TCA_EMATCH_TREE_LIST]);
+}
+
+struct bstr *bstr_alloc(const char *text)
+{
+	struct bstr *b = calloc(1, sizeof(*b));
+
+	if (b == NULL)
+		return NULL;
+
+	b->data = strdup(text);
+	if (b->data == NULL) {
+		free(b);
+		return NULL;
+	}
+
+	b->len = strlen(text);
+
+	return b;
+}
+
+unsigned long bstrtoul(const struct bstr *b)
+{
+	char *inv = NULL;
+	unsigned long l;
+	char buf[b->len+1];
+
+	memcpy(buf, b->data, b->len);
+	buf[b->len] = '\0';
+
+	l = strtoul(buf, &inv, 0);
+	if (l == ULONG_MAX || inv == buf)
+		return ULONG_MAX;
+
+	return l;
+}
+
+static void bstr_print(FILE *fd, const struct bstr *b, int ascii)
+{
+	int i;
+	char *s = b->data;
+
+	if (ascii)
+		for (i = 0; i < b->len; i++)
+		    fprintf(fd, "%c", isprint(s[i]) ? s[i] : '.');
+	else {
+		for (i = 0; i < b->len; i++)
+		    fprintf(fd, "%02x", s[i]);
+		fprintf(fd, "\"");
+		for (i = 0; i < b->len; i++)
+		    fprintf(fd, "%c", isprint(s[i]) ? s[i] : '.');
+		fprintf(fd, "\"");
+	}
+}