--- /dev/null
+/*
+ * lib/route/cls/u32.c u32 classifier
+ *
+ * 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) 2003-2006 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2005-2006 Petr Gotthard <petr.gotthard@siemens.com>
+ * Copyright (c) 2005-2006 Siemens AG Oesterreich
+ */
+
+/**
+ * @ingroup cls
+ * @defgroup u32 Universal 32-bit Classifier
+ *
+ * @{
+ */
+
+#include <netlink-local.h>
+#include <netlink-tc.h>
+#include <netlink/netlink.h>
+#include <netlink/attr.h>
+#include <netlink/utils.h>
+#include <netlink/route/tc.h>
+#include <netlink/route/classifier.h>
+#include <netlink/route/classifier-modules.h>
+#include <netlink/route/cls/u32.h>
+
+/** @cond SKIP */
+#define U32_ATTR_DIVISOR 0x001
+#define U32_ATTR_HASH 0x002
+#define U32_ATTR_CLASSID 0x004
+#define U32_ATTR_LINK 0x008
+#define U32_ATTR_PCNT 0x010
+#define U32_ATTR_SELECTOR 0x020
+#define U32_ATTR_ACTION 0x040
+#define U32_ATTR_POLICE 0x080
+#define U32_ATTR_INDEV 0x100
+/** @endcond */
+
+static inline struct rtnl_u32 *u32_cls(struct rtnl_cls *cls)
+{
+ return (struct rtnl_u32 *) cls->c_subdata;
+}
+
+static inline struct rtnl_u32 *u32_alloc(struct rtnl_cls *cls)
+{
+ if (!cls->c_subdata)
+ cls->c_subdata = calloc(1, sizeof(struct rtnl_u32));
+
+ return u32_cls(cls);
+}
+
+static inline struct tc_u32_sel *u32_selector(struct rtnl_u32 *u)
+{
+ return (struct tc_u32_sel *) u->cu_selector->d_data;
+}
+
+static inline struct tc_u32_sel *u32_selector_alloc(struct rtnl_u32 *u)
+{
+ if (!u->cu_selector)
+ u->cu_selector = nl_data_alloc(NULL, sizeof(struct tc_u32_sel));
+
+ return u32_selector(u);
+}
+
+static struct nla_policy u32_policy[TCA_U32_MAX+1] = {
+ [TCA_U32_DIVISOR] = { .type = NLA_U32 },
+ [TCA_U32_HASH] = { .type = NLA_U32 },
+ [TCA_U32_CLASSID] = { .type = NLA_U32 },
+ [TCA_U32_LINK] = { .type = NLA_U32 },
+ [TCA_U32_INDEV] = { .type = NLA_STRING,
+ .maxlen = IFNAMSIZ },
+ [TCA_U32_SEL] = { .minlen = sizeof(struct tc_u32_sel) },
+ [TCA_U32_PCNT] = { .minlen = sizeof(struct tc_u32_pcnt) },
+};
+
+static int u32_msg_parser(struct rtnl_cls *cls)
+{
+ int err;
+ struct nlattr *tb[TCA_U32_MAX + 1];
+ struct rtnl_u32 *u;
+
+ err = tca_parse(tb, TCA_U32_MAX, (struct rtnl_tca *) cls, u32_policy);
+ if (err < 0)
+ return err;
+
+ u = u32_alloc(cls);
+ if (!u)
+ goto errout_nomem;
+
+ if (tb[TCA_U32_DIVISOR]) {
+ u->cu_divisor = nla_get_u32(tb[TCA_U32_DIVISOR]);
+ u->cu_mask |= U32_ATTR_DIVISOR;
+ }
+
+ if (tb[TCA_U32_SEL]) {
+ u->cu_selector = nla_get_data(tb[TCA_U32_SEL]);
+ if (!u->cu_selector)
+ goto errout_nomem;
+ u->cu_mask |= U32_ATTR_SELECTOR;
+ }
+
+ if (tb[TCA_U32_HASH]) {
+ u->cu_hash = nla_get_u32(tb[TCA_U32_HASH]);
+ u->cu_mask |= U32_ATTR_HASH;
+ }
+
+ if (tb[TCA_U32_CLASSID]) {
+ u->cu_classid = nla_get_u32(tb[TCA_U32_CLASSID]);
+ u->cu_mask |= U32_ATTR_CLASSID;
+ }
+
+ if (tb[TCA_U32_LINK]) {
+ u->cu_link = nla_get_u32(tb[TCA_U32_LINK]);
+ u->cu_mask |= U32_ATTR_LINK;
+ }
+
+ if (tb[TCA_U32_ACT]) {
+ u->cu_act = nla_get_data(tb[TCA_U32_ACT]);
+ if (!u->cu_act)
+ goto errout_nomem;
+ u->cu_mask |= U32_ATTR_ACTION;
+ }
+
+ if (tb[TCA_U32_POLICE]) {
+ u->cu_police = nla_get_data(tb[TCA_U32_POLICE]);
+ if (!u->cu_police)
+ goto errout_nomem;
+ u->cu_mask |= U32_ATTR_POLICE;
+ }
+
+ if (tb[TCA_U32_PCNT]) {
+ struct tc_u32_sel *sel;
+ int pcnt_size;
+
+ if (!tb[TCA_U32_SEL]) {
+ err = nl_error(EINVAL, "Missing TCA_U32_SEL required "
+ "for TCA_U32_PCNT");
+ goto errout;
+ }
+
+ sel = u->cu_selector->d_data;
+ pcnt_size = sizeof(struct tc_u32_pcnt) +
+ (sel->nkeys * sizeof(uint64_t));
+ if (nla_len(tb[TCA_U32_PCNT]) < pcnt_size) {
+ err = nl_error(EINVAL, "Invalid size for TCA_U32_PCNT");
+ goto errout;
+ }
+
+ u->cu_pcnt = nla_get_data(tb[TCA_U32_PCNT]);
+ if (!u->cu_pcnt)
+ goto errout_nomem;
+ u->cu_mask |= U32_ATTR_PCNT;
+ }
+
+ if (tb[TCA_U32_INDEV]) {
+ nla_strlcpy(u->cu_indev, tb[TCA_U32_INDEV], IFNAMSIZ);
+ u->cu_mask |= U32_ATTR_INDEV;
+ }
+
+ return 0;
+
+errout_nomem:
+ err = nl_errno(ENOMEM);
+errout:
+ return err;
+}
+
+static void u32_free_data(struct rtnl_cls *cls)
+{
+ struct rtnl_u32 *u = u32_cls(cls);
+
+ if (!u)
+ return;
+
+ nl_data_free(u->cu_selector);
+ nl_data_free(u->cu_act);
+ nl_data_free(u->cu_police);
+ nl_data_free(u->cu_pcnt);
+
+ free(cls->c_subdata);
+}
+
+static int u32_dump_brief(struct rtnl_cls *cls, struct nl_dump_params *p,
+ int line)
+{
+ struct rtnl_u32 *u = u32_cls(cls);
+ char buf[32];
+
+ if (!u)
+ goto ignore;
+
+ if (u->cu_mask & U32_ATTR_DIVISOR)
+ dp_dump(p, " divisor %u", u->cu_divisor);
+ else if (u->cu_mask & U32_ATTR_CLASSID)
+ dp_dump(p, " target %s",
+ rtnl_tc_handle2str(u->cu_classid, buf, sizeof(buf)));
+
+ignore:
+ return line;
+}
+
+static int print_selector(struct nl_dump_params *p, struct tc_u32_sel *sel,
+ struct rtnl_cls *cls, struct rtnl_u32 *u, int line)
+{
+ int i;
+ struct tc_u32_key *key;
+
+ if (sel->hmask || sel->hoff) {
+ /* I guess this will never be used since the kernel only
+ * exports the selector if no divisor is set but hash offset
+ * and hash mask make only sense in hash filters with divisor
+ * set */
+ dp_dump(p, " hash at %u & 0x%x", sel->hoff, sel->hmask);
+ }
+
+ if (sel->flags & (TC_U32_OFFSET | TC_U32_VAROFFSET)) {
+ dp_dump(p, " offset at %u", sel->off);
+
+ if (sel->flags & TC_U32_VAROFFSET)
+ dp_dump(p, " variable (at %u & 0x%x) >> %u",
+ sel->offoff, ntohs(sel->offmask), sel->offshift);
+ }
+
+ if (sel->flags) {
+ int flags = sel->flags;
+ dp_dump(p, " <");
+
+#define PRINT_FLAG(f) if (flags & TC_U32_##f) { \
+ flags &= ~TC_U32_##f; dp_dump(p, #f "%s", flags ? "," : ""); }
+
+ PRINT_FLAG(TERMINAL);
+ PRINT_FLAG(OFFSET);
+ PRINT_FLAG(VAROFFSET);
+ PRINT_FLAG(EAT);
+#undef PRINT_FLAG
+
+ dp_dump(p, ">");
+ }
+
+
+ for (i = 0; i < sel->nkeys; i++) {
+ key = (struct tc_u32_key *) ((char *) sel + sizeof(*sel));
+
+ dp_dump(p, "\n");
+ dp_dump_line(p, line++, " match key at %s%u ",
+ key->offmask ? "nexthdr+" : "", key->off);
+
+ if (key->offmask)
+ dp_dump(p, "[0x%u] ", key->offmask);
+
+ dp_dump(p, "& 0x%08x == 0x%08x", ntohl(key->mask), ntohl(key->val));
+
+ if (p->dp_type == NL_DUMP_STATS &&
+ (u->cu_mask & U32_ATTR_PCNT)) {
+ struct tc_u32_pcnt *pcnt = u->cu_pcnt->d_data;
+ dp_dump(p, " successful %" PRIu64, pcnt->kcnts[i]);
+ }
+ }
+
+ return line;
+}
+
+
+static int u32_dump_full(struct rtnl_cls *cls, struct nl_dump_params *p,
+ int line)
+{
+ struct rtnl_u32 *u = u32_cls(cls);
+ struct tc_u32_sel *s;
+
+ if (!u)
+ goto ignore;
+
+ if (!(u->cu_mask & U32_ATTR_SELECTOR)) {
+ dp_dump(p, "no-selector\n");
+ return line;
+ }
+
+ s = u->cu_selector->d_data;
+
+ dp_dump(p, "nkeys %u ", s->nkeys);
+
+ if (u->cu_mask & U32_ATTR_HASH)
+ dp_dump(p, "ht key 0x%x hash 0x%u",
+ TC_U32_USERHTID(u->cu_hash), TC_U32_HASH(u->cu_hash));
+
+ if (u->cu_mask & U32_ATTR_LINK)
+ dp_dump(p, "link %u ", u->cu_link);
+
+ if (u->cu_mask & U32_ATTR_INDEV)
+ dp_dump(p, "indev %s ", u->cu_indev);
+
+ line = print_selector(p, s, cls, u, line);
+ dp_dump(p, "\n");
+
+ignore:
+ return line;
+
+#if 0
+#define U32_ATTR_ACTION 0x040
+#define U32_ATTR_POLICE 0x080
+
+ struct nl_data act;
+ struct nl_data police;
+#endif
+}
+
+static int u32_dump_stats(struct rtnl_cls *cls, struct nl_dump_params *p,
+ int line)
+{
+ struct rtnl_u32 *u = u32_cls(cls);
+
+ if (!u)
+ goto ignore;
+
+ if (u->cu_mask & U32_ATTR_PCNT) {
+ struct tc_u32_pcnt *pc = u->cu_pcnt->d_data;
+ dp_dump(p, "\n");
+ dp_dump_line(p, line++, "%s successful hits\n");
+ dp_dump_line(p, line++, "%s %8llu %8llu\n",
+ pc->rhit, pc->rcnt);
+ }
+
+ignore:
+ return line;
+}
+
+static struct nl_msg *u32_get_opts(struct rtnl_cls *cls)
+{
+ struct rtnl_u32 *u;
+ struct nl_msg *msg;
+
+ u = u32_cls(cls);
+ if (!u)
+ return NULL;
+
+ msg = nlmsg_build_no_hdr();
+ if (!msg)
+ return NULL;
+
+ if (u->cu_mask & U32_ATTR_DIVISOR)
+ nla_put_u32(msg, TCA_U32_DIVISOR, u->cu_divisor);
+
+ if (u->cu_mask & U32_ATTR_HASH)
+ nla_put_u32(msg, TCA_U32_HASH, u->cu_hash);
+
+ if (u->cu_mask & U32_ATTR_CLASSID)
+ nla_put_u32(msg, TCA_U32_CLASSID, u->cu_classid);
+
+ if (u->cu_mask & U32_ATTR_LINK)
+ nla_put_u32(msg, TCA_U32_LINK, u->cu_link);
+
+ if (u->cu_mask & U32_ATTR_SELECTOR)
+ nla_put_data(msg, TCA_U32_SEL, u->cu_selector);
+
+ if (u->cu_mask & U32_ATTR_ACTION)
+ nla_put_data(msg, TCA_U32_ACT, u->cu_act);
+
+ if (u->cu_mask & U32_ATTR_POLICE)
+ nla_put_data(msg, TCA_U32_POLICE, u->cu_police);
+
+ if (u->cu_mask & U32_ATTR_INDEV)
+ nla_put_string(msg, TCA_U32_INDEV, u->cu_indev);
+
+ return msg;
+}
+
+/**
+ * @name Attribute Modifications
+ * @{
+ */
+
+void rtnl_u32_set_handle(struct rtnl_cls *cls, int htid, int hash,
+ int nodeid)
+{
+ uint32_t handle = (htid << 20) | (hash << 12) | nodeid;
+
+ tca_set_handle((struct rtnl_tca *) cls, handle );
+}
+
+int rtnl_u32_set_classid(struct rtnl_cls *cls, uint32_t classid)
+{
+ struct rtnl_u32 *u;
+
+ u = u32_alloc(cls);
+ if (!u)
+ return nl_errno(ENOMEM);
+
+ u->cu_classid = classid;
+ u->cu_mask |= U32_ATTR_CLASSID;
+
+ return 0;
+}
+
+/** @} */
+
+/**
+ * @name Selector Modifications
+ * @{
+ */
+
+int rtnl_u32_set_flags(struct rtnl_cls *cls, int flags)
+{
+ struct tc_u32_sel *sel;
+ struct rtnl_u32 *u;
+
+ u = u32_alloc(cls);
+ if (!u)
+ return nl_errno(ENOMEM);
+
+ sel = u32_selector_alloc(u);
+ if (!sel)
+ return nl_errno(ENOMEM);
+
+ sel->flags |= flags;
+ u->cu_mask |= U32_ATTR_SELECTOR;
+
+ return 0;
+}
+
+/**
+ * Append new 32-bit key to the selector
+ *
+ * @arg cls classifier to be modifier
+ * @arg val value to be matched (network byte-order)
+ * @arg mask mask to be applied before matching (network byte-order)
+ * @arg off offset, in bytes, to start matching
+ * @arg offmask offset mask
+ *
+ * General selectors define the pattern, mask and offset the pattern will be
+ * matched to the packet contents. Using the general selectors you can match
+ * virtually any single bit in the IP (or upper layer) header.
+ *
+*/
+int rtnl_u32_add_key(struct rtnl_cls *cls, uint32_t val, uint32_t mask,
+ int off, int offmask)
+{
+ struct tc_u32_sel *sel;
+ struct rtnl_u32 *u;
+ int err;
+
+ u = u32_alloc(cls);
+ if (!u)
+ return nl_errno(ENOMEM);
+
+ sel = u32_selector_alloc(u);
+ if (!sel)
+ return nl_errno(ENOMEM);
+
+ err = nl_data_append(u->cu_selector, NULL, sizeof(struct tc_u32_key));
+ if (err < 0)
+ return err;
+
+ /* the selector might have been moved by realloc */
+ sel = u32_selector(u);
+
+ sel->keys[sel->nkeys].mask = mask;
+ sel->keys[sel->nkeys].val = val & mask;
+ sel->keys[sel->nkeys].off = off;
+ sel->keys[sel->nkeys].offmask = offmask;
+ sel->nkeys++;
+ u->cu_mask |= U32_ATTR_SELECTOR;
+
+ return 0;
+}
+
+int rtnl_u32_add_key_uint8(struct rtnl_cls *cls, uint8_t val, uint8_t mask,
+ int off, int offmask)
+{
+ int shift = 24 - 8 * (off & 3);
+
+ return rtnl_u32_add_key(cls, htonl((uint32_t)val << shift),
+ htonl((uint32_t)mask << shift),
+ off & ~3, offmask);
+}
+
+/**
+ * Append new selector key to match a 16-bit number
+ *
+ * @arg cls classifier to be modified
+ * @arg val value to be matched (host byte-order)
+ * @arg mask mask to be applied before matching (host byte-order)
+ * @arg off offset, in bytes, to start matching
+ * @arg offmask offset mask
+*/
+int rtnl_u32_add_key_uint16(struct rtnl_cls *cls, uint16_t val, uint16_t mask,
+ int off, int offmask)
+{
+ int shift = ((off & 3) == 0 ? 16 : 0);
+ if (off % 2)
+ return nl_error(EINVAL, "Invalid offset alignment");
+
+ return rtnl_u32_add_key(cls, htonl((uint32_t)val << shift),
+ htonl((uint32_t)mask << shift),
+ off & ~3, offmask);
+}
+
+/**
+ * Append new selector key to match a 32-bit number
+ *
+ * @arg cls classifier to be modified
+ * @arg val value to be matched (host byte-order)
+ * @arg mask mask to be applied before matching (host byte-order)
+ * @arg off offset, in bytes, to start matching
+ * @arg offmask offset mask
+*/
+int rtnl_u32_add_key_uint32(struct rtnl_cls *cls, uint32_t val, uint32_t mask,
+ int off, int offmask)
+{
+ return rtnl_u32_add_key(cls, htonl(val), htonl(mask),
+ off & ~3, offmask);
+}
+
+int rtnl_u32_add_key_in_addr(struct rtnl_cls *cls, struct in_addr *addr,
+ uint8_t bitmask, int off, int offmask)
+{
+ uint32_t mask = 0xFFFFFFFF << (32 - bitmask);
+ return rtnl_u32_add_key(cls, addr->s_addr, htonl(mask), off, offmask);
+}
+
+int rtnl_u32_add_key_in6_addr(struct rtnl_cls *cls, struct in6_addr *addr,
+ uint8_t bitmask, int off, int offmask)
+{
+ int i;
+
+ for (i = 1; i <= 4; i++) {
+ if (32 * i - bitmask <= 0)
+ return rtnl_u32_add_key(cls, addr->s6_addr32[i-1],
+ 0xFFFFFFFF, off, offmask );
+ else if (32 * i - bitmask < 32) {
+ uint32_t mask = 0xFFFFFFFF << (32 * i - bitmask);
+ return rtnl_u32_add_key(cls, addr->s6_addr32[i-1],
+ htonl(mask), off, offmask );
+ }
+ /* otherwise, if (32*i - bitmask >= 32) no key is generated */
+ }
+
+ return 0;
+}
+
+/** @} */
+
+static struct rtnl_cls_ops u32_ops = {
+ .co_kind = "u32",
+ .co_msg_parser = u32_msg_parser,
+ .co_free_data = u32_free_data,
+ .co_get_opts = u32_get_opts,
+ .co_dump[NL_DUMP_BRIEF] = u32_dump_brief,
+ .co_dump[NL_DUMP_FULL] = u32_dump_full,
+ .co_dump[NL_DUMP_STATS] = u32_dump_stats,
+};
+
+static void __init u32_init(void)
+{
+ rtnl_cls_register(&u32_ops);
+}
+
+static void __exit u32_exit(void)
+{
+ rtnl_cls_unregister(&u32_ops);
+}
+
+/** @} */
git://git.onelab.eu / libnl.git / blobdiff