[PKT_SCHED]: Packet classification based on textsearch (ematch)

Signed-off-by: Thomas Graf <tgraf@suug.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/linux/pkt_cls.h b/include/linux/pkt_cls.h
index d2aa214d68032fb2d70c51b939257cf762f32e21..25d2d67c1faf813cde122f8a1df121c513d2112d 100644 (file)
--- a/include/linux/pkt_cls.h
+++ b/include/linux/pkt_cls.h
@@ -408,6 +408,7 @@ enum
        TCF_EM_NBYTE,
        TCF_EM_U32,
        TCF_EM_META,
+       TCF_EM_TEXT,
        __TCF_EM_MAX
 };
 

diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index e68dbf0bf5791f1e0a4e08098fdbf2e9995195e1..d021888b58f12ba73bef458cbdcca13ca9af2723 100644 (file)
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -892,10 +892,13 @@ extern void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const voi
                 goto rtattr_failure; \
        __rta_fill(skb, attrtype, attrlen, data); }) 
 
-#define RTA_PUT_NOHDR(skb, attrlen, data) \
+#define RTA_APPEND(skb, attrlen, data) \
 ({     if (unlikely(skb_tailroom(skb) < (int)(attrlen))) \
                goto rtattr_failure; \
-       memcpy(skb_put(skb, RTA_ALIGN(attrlen)), data, attrlen); })
+       memcpy(skb_put(skb, attrlen), data, attrlen); })
+
+#define RTA_PUT_NOHDR(skb, attrlen, data) \
+       RTA_APPEND(skb, RTA_ALIGN(attrlen), data)
 
 #define RTA_PUT_U8(skb, attrtype, value) \
 ({     u8 _tmp = (value); \

diff --git a/include/linux/tc_ematch/tc_em_text.h b/include/linux/tc_ematch/tc_em_text.h
new file mode 100644 (file)
index 0000000..7cd43e9
--- /dev/null
+++ b/include/linux/tc_ematch/tc_em_text.h
@@ -0,0 +1,19 @@
+#ifndef __LINUX_TC_EM_TEXT_H
+#define __LINUX_TC_EM_TEXT_H
+
+#include <linux/pkt_cls.h>
+
+#define TC_EM_TEXT_ALGOSIZ     16
+
+struct tcf_em_text
+{
+       char            algo[TC_EM_TEXT_ALGOSIZ];
+       __u16           from_offset;
+       __u16           to_offset;
+       __u16           pattern_len;
+       __u8            from_layer:4;
+       __u8            to_layer:4;
+       __u8            pad;
+};
+
+#endif

diff --git a/net/sched/Kconfig b/net/sched/Kconfig
index b22c9beb604d78eb3dbf32809112802cb0b597ee..95d9bc5d86215579e3707998cece8c93ac018ae3 100644 (file)
--- a/net/sched/Kconfig
+++ b/net/sched/Kconfig
@@ -449,6 +449,17 @@ config NET_EMATCH_META
          To compile this code as a module, choose M here: the
          module will be called em_meta.
 
+config NET_EMATCH_TEXT
+       tristate "Textsearch"
+       depends on NET_EMATCH
+       ---help---
+         Say Y here if you want to be ablt to classify packets based on
+         textsearch comparisons. Please select the appropriate textsearch
+         algorithms in the Library section.
+
+         To compile this code as a module, choose M here: the
+         module will be called em_text.
+
 config NET_CLS_ACT
        bool "Packet ACTION"
        depends on EXPERIMENTAL && NET_CLS && NET_QOS

diff --git a/net/sched/Makefile b/net/sched/Makefile
index eb3fe583eba8d85aab104c9acd588d10ccab4591..8f58cecd6266eedae186f08f6eb86c31bfc7a391 100644 (file)
--- a/net/sched/Makefile
+++ b/net/sched/Makefile
@@ -40,3 +40,4 @@ obj-$(CONFIG_NET_EMATCH_CMP)  += em_cmp.o
 obj-$(CONFIG_NET_EMATCH_NBYTE) += em_nbyte.o
 obj-$(CONFIG_NET_EMATCH_U32)   += em_u32.o
 obj-$(CONFIG_NET_EMATCH_META)  += em_meta.o
+obj-$(CONFIG_NET_EMATCH_TEXT)  += em_text.o

diff --git a/net/sched/em_text.c b/net/sched/em_text.c
new file mode 100644 (file)
index 0000000..873840d
--- /dev/null
+++ b/net/sched/em_text.c
@@ -0,0 +1,157 @@
+/*
+ * net/sched/em_text.c Textsearch ematch
+ *
+ *             This program is free software; you can redistribute 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 <linux/config.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/skbuff.h>
+#include <linux/textsearch.h>
+#include <linux/tc_ematch/tc_em_text.h>
+#include <net/pkt_cls.h>
+
+struct text_match
+{
+       u16                     from_offset;
+       u16                     to_offset;
+       u8                      from_layer;
+       u8                      to_layer;
+       struct ts_config        *config;
+};
+
+#define EM_TEXT_PRIV(m) ((struct text_match *) (m)->data)
+
+static int em_text_match(struct sk_buff *skb, struct tcf_ematch *m,
+                        struct tcf_pkt_info *info)
+{
+       struct text_match *tm = EM_TEXT_PRIV(m);
+       int from, to;
+       struct ts_state state;
+
+       from = tcf_get_base_ptr(skb, tm->from_layer) - skb->data;
+       from += tm->from_offset;
+
+       to = tcf_get_base_ptr(skb, tm->to_layer) - skb->data;
+       to += tm->to_offset;
+
+       return skb_find_text(skb, from, to, tm->config, &state) != UINT_MAX;
+}
+
+static int em_text_change(struct tcf_proto *tp, void *data, int len,
+                         struct tcf_ematch *m)
+{
+       struct text_match *tm;
+       struct tcf_em_text *conf = data;
+       struct ts_config *ts_conf;
+       int flags = 0;
+
+       printk("Configuring text: %s from %d:%d to %d:%d len %d\n", conf->algo, conf->from_offset,
+           conf->from_layer, conf->to_offset, conf->to_layer, conf->pattern_len);
+
+       if (len < sizeof(*conf) || len < (sizeof(*conf) + conf->pattern_len))
+               return -EINVAL;
+
+       if (conf->from_layer > conf->to_layer)
+               return -EINVAL;
+
+       if (conf->from_layer == conf->to_layer &&
+           conf->from_offset > conf->to_offset)
+               return -EINVAL;
+
+retry:
+       ts_conf = textsearch_prepare(conf->algo, (u8 *) conf + sizeof(*conf),
+                                    conf->pattern_len, GFP_KERNEL, flags);
+
+       if (flags & TS_AUTOLOAD)
+               rtnl_lock();
+
+       if (IS_ERR(ts_conf)) {
+               if (PTR_ERR(ts_conf) == -ENOENT && !(flags & TS_AUTOLOAD)) {
+                       rtnl_unlock();
+                       flags |= TS_AUTOLOAD;
+                       goto retry;
+               } else
+                       return PTR_ERR(ts_conf);
+       } else if (flags & TS_AUTOLOAD) {
+               textsearch_destroy(ts_conf);
+               return -EAGAIN;
+       }
+
+       tm = kmalloc(sizeof(*tm), GFP_KERNEL);
+       if (tm == NULL) {
+               textsearch_destroy(ts_conf);
+               return -ENOBUFS;
+       }
+
+       tm->from_offset = conf->from_offset;
+       tm->to_offset   = conf->to_offset;
+       tm->from_layer  = conf->from_layer;
+       tm->to_layer    = conf->to_layer;
+       tm->config      = ts_conf;
+
+       m->datalen = sizeof(*tm);
+       m->data = (unsigned long) tm;
+
+       return 0;
+}
+
+static void em_text_destroy(struct tcf_proto *tp, struct tcf_ematch *m)
+{
+       textsearch_destroy(EM_TEXT_PRIV(m)->config);
+}
+
+static int em_text_dump(struct sk_buff *skb, struct tcf_ematch *m)
+{
+       struct text_match *tm = EM_TEXT_PRIV(m);
+       struct tcf_em_text conf;
+
+       strncpy(conf.algo, tm->config->ops->name, sizeof(conf.algo) - 1);
+       conf.from_offset = tm->from_offset;
+       conf.to_offset = tm->to_offset;
+       conf.from_layer = tm->from_layer;
+       conf.to_layer = tm->to_layer;
+       conf.pattern_len = textsearch_get_pattern_len(tm->config);
+       conf.pad = 0;
+
+       RTA_PUT_NOHDR(skb, sizeof(conf), &conf);
+       RTA_APPEND(skb, conf.pattern_len, textsearch_get_pattern(tm->config));
+       return 0;
+
+rtattr_failure:
+       return -1;
+}              
+
+static struct tcf_ematch_ops em_text_ops = {
+       .kind     = TCF_EM_TEXT,
+       .change   = em_text_change,
+       .match    = em_text_match,
+       .destroy  = em_text_destroy,
+       .dump     = em_text_dump,
+       .owner    = THIS_MODULE,
+       .link     = LIST_HEAD_INIT(em_text_ops.link)
+};
+
+static int __init init_em_text(void)
+{
+       return tcf_em_register(&em_text_ops);
+}
+
+static void __exit exit_em_text(void) 
+{
+       tcf_em_unregister(&em_text_ops);
+}
+
+MODULE_LICENSE("GPL");
+
+module_init(init_em_text);
+module_exit(exit_em_text);