1 files changed, 410 insertions, 0 deletions
diff --git a/lib/route/cls/ematch.c b/lib/route/cls/ematch.c
new file mode 100644
index 0000000..cb77b16
--- /dev/null
+++ b/lib/route/cls/ematch.c
@@ -0,0 +1,410 @@
+/*
+ * lib/route/cls/ematch.c	Extended Matches
+ *
+ *	This library is free software; you can redistribute it and/or
+ *	modify it under the terms of the GNU Lesser General Public
+ *	License as published by the Free Software Foundation version 2.1
+ *	of the License.
+ *
+ * Copyright (c) 2008-2009 Thomas Graf <tgraf@suug.ch>
+ */
+
+/**
+ * @ingroup cls
+ * @defgroup ematch Extended Match
+ *
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink-tc.h>
+#include <netlink/netlink.h>
+#include <netlink/route/classifier.h>
+#include <netlink/route/classifier-modules.h>
+#include <netlink/route/cls/ematch.h>
+
+/**
+ * @name Module Registration
+ * @{
+ */
+
+static NL_LIST_HEAD(ematch_ops_list);
+
+/**
+ * Register ematch module
+ * @arg ops		Module operations.
+ *
+ * @return 0 on success or a negative error code.
+ */
+int rtnl_ematch_register(struct rtnl_ematch_ops *ops)
+{
+	if (rtnl_ematch_lookup_ops(ops->eo_kind))
+		return -NLE_EXIST;
+
+	nl_list_add_tail(&ops->eo_list, &ematch_ops_list);
+
+	return 0;
+}
+
+/**
+ * Unregister ematch module
+ * @arg ops		Module operations.
+ *
+ * @return 0 on success or a negative error code.
+ */
+int rtnl_ematch_unregister(struct rtnl_ematch_ops *ops)
+{
+	struct rtnl_ematch_ops *o;
+
+	nl_list_for_each_entry(o, &ematch_ops_list, eo_list) {
+		if (ops->eo_kind == o->eo_kind) {
+			nl_list_del(&o->eo_list);
+			return 0;
+		}
+	}
+
+	return -NLE_OBJ_NOTFOUND;
+}
+
+/**
+ * Lookup ematch module by kind
+ * @arg kind		Module kind.
+ *
+ * @return Module operations or NULL if not found.
+ */
+struct rtnl_ematch_ops *rtnl_ematch_lookup_ops(int kind)
+{
+	struct rtnl_ematch_ops *ops;
+
+	nl_list_for_each_entry(ops, &ematch_ops_list, eo_list)
+		if (ops->eo_kind == kind)
+			return ops;
+
+	return NULL;
+}
+
+/**
+ * Lookup ematch module by name
+ * @arg name		Name of ematch module.
+ *
+ * @return Module operations or NULL if not fuond.
+ */
+struct rtnl_ematch_ops *rtnl_ematch_lookup_ops_name(const char *name)
+{
+	struct rtnl_ematch_ops *ops;
+
+	nl_list_for_each_entry(ops, &ematch_ops_list, eo_list)
+		if (!strcasecmp(ops->eo_name, name))
+			return ops;
+
+	return NULL;
+}
+
+/** @} */
+
+/**
+ * @name Match
+ */
+
+struct rtnl_ematch *rtnl_ematch_alloc(struct rtnl_ematch_ops *ops)
+{
+	struct rtnl_ematch *e;
+	size_t len = sizeof(*e) + (ops ? ops->eo_datalen : 0);
+
+	if (!(e = calloc(1, len)))
+		return NULL;
+
+	NL_INIT_LIST_HEAD(&e->e_list);
+	NL_INIT_LIST_HEAD(&e->e_childs);
+
+	if (ops) {
+		e->e_ops = ops;
+		e->e_kind = ops->eo_kind;
+	}
+
+	return e;
+}
+
+/**
+ * Add ematch to the end of the parent's list of children.
+ * @arg parent		Parent ematch.
+ * @arg child		Ematch to be added as new child of parent.
+ */
+void rtnl_ematch_add_child(struct rtnl_ematch *parent,
+			   struct rtnl_ematch *child)
+{
+	nl_list_add_tail(&child->e_list, &parent->e_childs);
+}
+
+/**
+ * Remove ematch from the list it is linked to.
+ * @arg ematch		Ematch to be unlinked.
+ */
+void rtnl_ematch_unlink(struct rtnl_ematch *ematch)
+{
+	nl_list_del(&ematch->e_list);
+}
+
+void rtnl_ematch_free(struct rtnl_ematch *ematch)
+{
+	if (!ematch)
+		return;
+
+	free(ematch);
+}
+
+void rtnl_ematch_set_flags(struct rtnl_ematch *ematch, uint16_t flags)
+{
+	ematch->e_flags |= flags;
+}
+
+void rtnl_ematch_unset_flags(struct rtnl_ematch *ematch, uint16_t flags)
+{
+	ematch->e_flags &= ~flags;
+}
+
+uint16_t rtnl_ematch_get_flags(struct rtnl_ematch *ematch)
+{
+	return ematch->e_flags;
+}
+
+void *rtnl_ematch_data(struct rtnl_ematch *ematch)
+{
+	return ematch->e_data;
+}
+
+/** @} */
+
+/**
+ * @name Tree
+ */
+
+struct rtnl_ematch_tree *rtnl_ematch_tree_alloc(uint16_t progid)
+{
+	struct rtnl_ematch_tree *tree;
+
+	if (!(tree = calloc(1, sizeof(*tree))))
+		return NULL;
+
+	NL_INIT_LIST_HEAD(&tree->et_list);
+	tree->et_progid = progid;
+
+	return tree;
+}
+
+static void free_ematch_list(struct nl_list_head *head)
+{
+	struct rtnl_ematch *pos, *next;
+
+	nl_list_for_each_entry_safe(pos, next, head, e_list) {
+		if (!nl_list_empty(&pos->e_childs))
+			free_ematch_list(&pos->e_childs);
+		rtnl_ematch_free(pos);
+	}
+}
+
+void rtnl_ematch_tree_free(struct rtnl_ematch_tree *tree)
+{
+	if (!tree)
+		return;
+
+	free_ematch_list(&tree->et_list);
+	free(tree);
+}
+
+void rtnl_ematch_tree_add_tail(struct rtnl_ematch_tree *tree,
+			       struct rtnl_ematch *ematch)
+{
+	nl_list_add_tail(&ematch->e_list, &tree->et_list);
+}
+
+static inline uint32_t container_ref(struct rtnl_ematch *ematch)
+{
+	return *((uint32_t *) rtnl_ematch_data(ematch));
+}
+
+static int link_tree(struct rtnl_ematch *index[], int nmatches, int pos,
+		     struct nl_list_head *root)
+{
+	struct rtnl_ematch *ematch;
+	int i;
+
+	for (i = pos; i < nmatches; i++) {
+		ematch = index[i];
+
+		nl_list_add_tail(&ematch->e_list, root);
+
+		if (ematch->e_kind == TCF_EM_CONTAINER)
+			link_tree(index, nmatches, container_ref(ematch),
+				  &ematch->e_childs);
+
+		if (!(ematch->e_flags & TCF_EM_REL_MASK))
+			return 0;
+	}
+
+	/* Last entry in chain can't possibly have no relation */
+	return -NLE_INVAL;
+}
+
+static struct nla_policy tree_policy[TCA_EMATCH_TREE_MAX+1] = {
+	[TCA_EMATCH_TREE_HDR]  = { .minlen=sizeof(struct tcf_ematch_tree_hdr) },
+	[TCA_EMATCH_TREE_LIST] = { .type = NLA_NESTED },
+};
+
+/**
+ * Parse ematch netlink attributes
+ *
+ * @return 0 on success or a negative error code.
+ */
+int rtnl_ematch_parse(struct nlattr *attr, struct rtnl_ematch_tree **result)
+{
+	struct nlattr *a, *tb[TCA_EMATCH_TREE_MAX+1];
+	struct tcf_ematch_tree_hdr *thdr;
+	struct rtnl_ematch_tree *tree;
+	struct rtnl_ematch **index;
+	int nmatches = 0, err, remaining;
+
+	err = nla_parse_nested(tb, TCA_EMATCH_TREE_MAX, attr, tree_policy);
+	if (err < 0)
+		return err;
+
+	if (!tb[TCA_EMATCH_TREE_HDR])
+		return -NLE_MISSING_ATTR;
+
+	thdr = nla_data(tb[TCA_EMATCH_TREE_HDR]);
+
+	/* Ignore empty trees */
+	if (thdr->nmatches == 0)
+		return 0;
+
+	if (!tb[TCA_EMATCH_TREE_LIST])
+		return -NLE_MISSING_ATTR;
+
+	if (thdr->nmatches > (nla_len(tb[TCA_EMATCH_TREE_LIST]) /
+			      nla_total_size(sizeof(struct tcf_ematch_hdr))))
+		return -NLE_INVAL;
+
+	if (!(index = calloc(thdr->nmatches, sizeof(struct rtnl_ematch *))))
+		return -NLE_NOMEM;
+
+	if (!(tree = rtnl_ematch_tree_alloc(thdr->progid))) {
+		err = -NLE_NOMEM;
+		goto errout;
+	}
+
+	nla_for_each_nested(a, tb[TCA_EMATCH_TREE_LIST], remaining) {
+		struct rtnl_ematch_ops *ops;
+		struct tcf_ematch_hdr *hdr;
+		struct rtnl_ematch *ematch;
+		void *data;
+		size_t len;
+
+		if (nla_len(a) < sizeof(*hdr)) {
+			err = -NLE_INVAL;
+			goto errout;
+		}
+
+		if (nmatches >= thdr->nmatches) {
+			err = -NLE_RANGE;
+			goto errout;
+		}
+
+		hdr = nla_data(a);
+		data = nla_data(a) + NLA_ALIGN(sizeof(*hdr));
+		len = nla_len(a) - NLA_ALIGN(sizeof(*hdr));
+
+		ops = rtnl_ematch_lookup_ops(hdr->kind);
+		if (ops && ops->eo_datalen && len < ops->eo_datalen) {
+			err = -NLE_INVAL;
+			goto errout;
+		}
+
+		if (!(ematch = rtnl_ematch_alloc(ops))) {
+			err = -NLE_NOMEM;
+			goto errout;
+		}
+
+		ematch->e_id = hdr->matchid;
+		ematch->e_kind = hdr->kind;
+		ematch->e_flags = hdr->flags;
+
+		if (ops && (err = ops->eo_parse(ematch, data, len)) < 0)
+			goto errout;
+
+		if (hdr->kind == TCF_EM_CONTAINER &&
+		    container_ref(ematch) >= thdr->nmatches) {
+			err = -NLE_INVAL;
+			goto errout;
+		}
+
+		index[nmatches++] = ematch;
+	}
+
+	if (nmatches != thdr->nmatches) {
+		err = -NLE_INVAL;
+		goto errout;
+	}
+
+	err = link_tree(index, nmatches, 0, &tree->et_list);
+	if (err < 0)
+		goto errout;
+
+	free(index);
+	*result = tree;
+
+	return 0;
+
+errout:
+	rtnl_ematch_tree_free(tree);
+	free(index);
+	return err;
+}
+
+static void dump_ematch_sequence(struct nl_list_head *head,
+				 struct nl_dump_params *p)
+{
+	struct rtnl_ematch *match;
+
+	nl_list_for_each_entry(match, head, e_list) {
+		if (match->e_flags & TCF_EM_INVERT)
+			nl_dump(p, "NOT ");
+
+		if (match->e_kind == TCF_EM_CONTAINER) {
+			nl_dump(p, "(");
+			dump_ematch_sequence(&match->e_childs, p);
+			nl_dump(p, ")");
+		} else if (!match->e_ops) {
+			nl_dump(p, "[unknown ematch %d]", match->e_kind);
+		} else {
+			nl_dump(p, "%s(", match->e_ops->eo_name);
+
+			if (match->e_ops->eo_dump)
+				match->e_ops->eo_dump(match, p);
+
+			nl_dump(p, ")");
+		}
+
+		switch (match->e_flags & TCF_EM_REL_MASK) {
+		case TCF_EM_REL_AND:
+			nl_dump(p, " AND ");
+			break;
+		case TCF_EM_REL_OR:
+			nl_dump(p, " OR ");
+			break;
+		default:
+			/* end of first level ematch sequence */
+			return;
+		}
+	}
+}
+
+void rtnl_ematch_tree_dump(struct rtnl_ematch_tree *tree,
+			   struct nl_dump_params *p)
+{
+	dump_ematch_sequence(&tree->et_list, p);
+	nl_dump(p, "\n");
+}
+
+/** @} */
+
+/** @} */