new ip6 FRAG match by kisza

diff --git a/extensions/.frag-test6 b/extensions/.frag-test6
new file mode 100755 (executable)
index 0000000..ff3650d
--- /dev/null
+++ b/extensions/.frag-test6
@@ -0,0 +1,2 @@
+#!/bin/sh
+[ -f $KERNEL_DIR/net/ipv6/netfilter/ip6t_frag.c -a -f $KERNEL_DIR/include/linux/netfilter_ipv6/ip6t_frag.h ] && echo frag

diff --git a/extensions/libip6t_frag.c b/extensions/libip6t_frag.c
new file mode 100644 (file)
index 0000000..aabb334
--- /dev/null
+++ b/extensions/libip6t_frag.c
@@ -0,0 +1,273 @@
+/* Shared library add-on to ip6tables to add Fragmentation header support. */
+#include <stdio.h>
+#include <netdb.h>
+#include <string.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <errno.h>
+#include <ip6tables.h>
+#include <linux/netfilter_ipv6/ip6t_frag.h>
+                                        
+/* Function which prints out usage message. */
+static void
+help(void)
+{
+       printf(
+"FRAG v%s options:\n"
+" --fragid [!] id[:id]          match the id (range)\n"
+" --fraglen [!] length          total length of this header\n"
+" --fragres                     check the reserved filed, too\n"
+" --fragfirst                   matches on the frst fragment\n"
+" [--fragmore|--fraglast]       there are more fragments or this\n"
+"                               is the last one\n",
+NETFILTER_VERSION);
+}
+
+static struct option opts[] = {
+       { "fragid", 1, 0, '1' },
+       { "fraglen", 1, 0, '2' },
+       { "fragres", 0, 0, '3' },
+       { "fragfirst", 0, 0, '4' },
+       { "fragmore", 0, 0, '5' },
+       { "fraglast", 0, 0, '6' },
+       {0}
+};
+
+static u_int32_t
+parse_frag_id(const char *idstr, const char *typestr)
+{
+       unsigned long int id;
+       char* ep;
+
+       id =  strtoul(idstr,&ep,0) ;
+
+       if ( idstr == ep ) {
+               exit_error(PARAMETER_PROBLEM,
+                          "FRAG no valid digits in %s `%s'", typestr, idstr);
+       }
+       if ( id == ULONG_MAX  && errno == ERANGE ) {
+               exit_error(PARAMETER_PROBLEM,
+                          "%s `%s' specified too big: would overflow",
+                          typestr, idstr);
+       }       
+       if ( *idstr != '\0'  && *ep != '\0' ) {
+               exit_error(PARAMETER_PROBLEM,
+                          "FRAG error parsing %s `%s'", typestr, idstr);
+       }
+       return (u_int32_t) id;
+}
+
+static void
+parse_frag_ids(const char *idstring, u_int32_t *ids)
+{
+       char *buffer;
+       char *cp;
+
+       buffer = strdup(idstring);
+       if ((cp = strchr(buffer, ':')) == NULL)
+               ids[0] = ids[1] = parse_frag_id(buffer,"id");
+       else {
+               *cp = '\0';
+               cp++;
+
+               ids[0] = buffer[0] ? parse_frag_id(buffer,"id") : 0;
+               ids[1] = cp[0] ? parse_frag_id(cp,"id") : 0xFFFFFFFF;
+       }
+       free(buffer);
+}
+
+/* Initialize the match. */
+static void
+init(struct ip6t_entry_match *m, unsigned int *nfcache)
+{
+       struct ip6t_frag *fraginfo = (struct ip6t_frag *)m->data;
+
+       fraginfo->ids[0] = 0x0L;
+       fraginfo->ids[1] = 0xFFFFFFFF;
+       fraginfo->hdrlen = 0;
+       fraginfo->flags = 0;
+       fraginfo->invflags = 0;
+}
+
+/* Function which parses command options; returns true if it
+   ate an option */
+static int
+parse(int c, char **argv, int invert, unsigned int *flags,
+      const struct ip6t_entry *entry,
+      unsigned int *nfcache,
+      struct ip6t_entry_match **match)
+{
+       struct ip6t_frag *fraginfo = (struct ip6t_frag *)(*match)->data;
+
+       switch (c) {
+       case '1':
+               if (*flags & IP6T_FRAG_IDS)
+                       exit_error(PARAMETER_PROBLEM,
+                                  "Only one `--fragid' allowed");
+               check_inverse(optarg, &invert, &optind, 0);
+               parse_frag_ids(argv[optind-1], fraginfo->ids);
+               if (invert)
+                       fraginfo->invflags |= IP6T_FRAG_INV_IDS;
+               fraginfo->flags |= IP6T_FRAG_IDS;
+               *flags |= IP6T_FRAG_IDS;
+               break;
+       case '2':
+               if (*flags & IP6T_FRAG_LEN)
+                       exit_error(PARAMETER_PROBLEM,
+                                  "Only one `--fraglen' allowed");
+               check_inverse(optarg, &invert, &optind, 0);
+               fraginfo->hdrlen = parse_frag_id(argv[optind-1], "length");
+               if (invert)
+                       fraginfo->invflags |= IP6T_FRAG_INV_LEN;
+               fraginfo->flags |= IP6T_FRAG_LEN;
+               *flags |= IP6T_FRAG_LEN;
+               break;
+       case '3':
+               if (*flags & IP6T_FRAG_RES)
+                       exit_error(PARAMETER_PROBLEM,
+                                  "Only one `--fragres' allowed");
+               fraginfo->flags |= IP6T_FRAG_RES;
+               *flags |= IP6T_FRAG_RES;
+               break;
+       case '4':
+               if (*flags & IP6T_FRAG_FST)
+                       exit_error(PARAMETER_PROBLEM,
+                                  "Only one `--fragfirst' allowed");
+               fraginfo->flags |= IP6T_FRAG_FST;
+               *flags |= IP6T_FRAG_FST;
+               break;
+       case '5':
+               if (*flags & (IP6T_FRAG_MF|IP6T_FRAG_NMF)) 
+                       exit_error(PARAMETER_PROBLEM,
+                          "Only one `--fragmore' or `--fraglast' allowed");
+               fraginfo->flags |= IP6T_FRAG_MF;
+               *flags |= IP6T_FRAG_MF;
+               break;
+       case '6':
+               if (*flags & (IP6T_FRAG_MF|IP6T_FRAG_NMF)) 
+                       exit_error(PARAMETER_PROBLEM,
+                          "Only one `--fragmore' or `--fraglast' allowed");
+               fraginfo->flags |= IP6T_FRAG_NMF;
+               *flags |= IP6T_FRAG_NMF;
+               break;
+       default:
+               return 0;
+       }
+
+       return 1;
+}
+
+/* Final check; we don't care. */
+static void
+final_check(unsigned int flags)
+{
+}
+
+static void
+print_ids(const char *name, u_int32_t min, u_int32_t max,
+           int invert)
+{
+       const char *inv = invert ? "!" : "";
+
+       if (min != 0 || max != 0xFFFFFFFF || invert) {
+               printf("%s", name);
+               if (min == max) {
+                       printf(":%s", inv);
+                       printf("%u", min);
+               } else {
+                       printf("s:%s", inv);
+                       printf("%u",min);
+                       printf(":");
+                       printf("%u",max);
+               }
+               printf(" ");
+       }
+}
+
+static void
+print_len(const char *name, u_int32_t len, int invert)
+{
+       const char *inv = invert ? "!" : "";
+
+       if (len != 0 || invert) {
+               printf("%s", name);
+               printf(":%s", inv);
+               printf("%u", len);
+               printf(" ");
+       }
+}
+
+/* Prints out the union ip6t_matchinfo. */
+static void
+print(const struct ip6t_ip6 *ip,
+      const struct ip6t_entry_match *match, int numeric)
+{
+       const struct ip6t_frag *frag = (struct ip6t_frag *)match->data;
+
+       printf("frag ");
+       print_ids("id", frag->ids[0], frag->ids[1],
+                   frag->invflags & IP6T_FRAG_INV_IDS);
+       print_len("length", frag->hdrlen, 
+                   frag->invflags & IP6T_FRAG_INV_LEN);
+       if (frag->flags & IP6T_FRAG_RES) printf("reserved ");
+       if (frag->flags & IP6T_FRAG_FST) printf("first ");
+       if (frag->flags & IP6T_FRAG_MF) printf("more ");
+       if (frag->flags & IP6T_FRAG_NMF) printf("last ");
+       if (frag->invflags & ~IP6T_FRAG_INV_MASK)
+               printf("Unknown invflags: 0x%X ",
+                      frag->invflags & ~IP6T_FRAG_INV_MASK);
+}
+
+/* Saves the union ip6t_matchinfo in parsable form to stdout. */
+static void save(const struct ip6t_ip6 *ip, const struct ip6t_entry_match *match)
+{
+       const struct ip6t_frag *fraginfo = (struct ip6t_frag *)match->data;
+
+       if (!(fraginfo->ids[0] == 0
+           && fraginfo->ids[1] == 0xFFFFFFFF)) {
+               printf("--fragid %s", 
+                       (fraginfo->invflags & IP6T_FRAG_INV_IDS) ? "! " : "");
+               if (fraginfo->ids[0]
+                   != fraginfo->ids[1])
+                       printf("%u:%u ",
+                              fraginfo->ids[0],
+                              fraginfo->ids[1]);
+               else
+                       printf("%u ",
+                              fraginfo->ids[0]);
+       }
+
+       if (fraginfo->hdrlen != 0 ) {
+               printf("--fraglen %s%u ", 
+                       (fraginfo->invflags & IP6T_FRAG_INV_LEN) ? "! " : "", 
+                       fraginfo->hdrlen);
+       }
+
+       if (fraginfo->flags & IP6T_FRAG_RES) printf("--fragres ");
+       if (fraginfo->flags & IP6T_FRAG_FST) printf("--fragfirst ");
+       if (fraginfo->flags & IP6T_FRAG_MF) printf("--fragmore ");
+       if (fraginfo->flags & IP6T_FRAG_NMF) printf("--fraglast ");
+
+}
+
+static
+struct ip6tables_match frag
+= { NULL,
+    "frag",
+    NETFILTER_VERSION,
+    IP6T_ALIGN(sizeof(struct ip6t_frag)),
+    IP6T_ALIGN(sizeof(struct ip6t_frag)),
+    &help,
+    &init,
+    &parse,
+    &final_check,
+    &print,
+    &save,
+    opts
+};
+
+void
+_init(void)
+{
+       register_match6(&frag);
+}

diff --git a/include/linux/netfilter_ipv6/ip6t_ah.h b/include/linux/netfilter_ipv6/ip6t_ah.h
index 8531879eb4645424712e8c8893ea30102b2bf2a1..c4f0793a0a98b5b1ae40154dcb51a5a8ad65da37 100644 (file)
--- a/include/linux/netfilter_ipv6/ip6t_ah.h
+++ b/include/linux/netfilter_ipv6/ip6t_ah.h
@@ -18,4 +18,13 @@ struct ip6t_ah
 #define IP6T_AH_INV_LEN                0x02    /* Invert the sense of length. */
 #define IP6T_AH_INV_MASK       0x03    /* All possible flags. */
 
+#define MASK_HOPOPTS    128
+#define MASK_DSTOPTS    64
+#define MASK_ROUTING    32
+#define MASK_FRAGMENT   16
+#define MASK_AH         8
+#define MASK_ESP        4
+#define MASK_NONE       2
+#define MASK_PROTO      1
+
 #endif /*_IP6T_AH_H*/

diff --git a/include/linux/netfilter_ipv6/ip6t_frag.h b/include/linux/netfilter_ipv6/ip6t_frag.h
new file mode 100644 (file)
index 0000000..449a57e
--- /dev/null
+++ b/include/linux/netfilter_ipv6/ip6t_frag.h
@@ -0,0 +1,33 @@
+#ifndef _IP6T_FRAG_H
+#define _IP6T_FRAG_H
+
+struct ip6t_frag
+{
+       u_int32_t ids[2];                       /* Security Parameter Index */
+       u_int32_t hdrlen;                       /* Header Length */
+       u_int8_t  flags;                        /*  */
+       u_int8_t  invflags;                     /* Inverse flags */
+};
+
+#define IP6T_FRAG_IDS          0x01
+#define IP6T_FRAG_LEN          0x02
+#define IP6T_FRAG_RES          0x04
+#define IP6T_FRAG_FST          0x08
+#define IP6T_FRAG_MF           0x10
+#define IP6T_FRAG_NMF                  0x20
+
+/* Values for "invflags" field in struct ip6t_frag. */
+#define IP6T_FRAG_INV_IDS      0x01    /* Invert the sense of ids. */
+#define IP6T_FRAG_INV_LEN      0x02    /* Invert the sense of length. */
+#define IP6T_FRAG_INV_MASK     0x03    /* All possible flags. */
+
+#define MASK_HOPOPTS    128
+#define MASK_DSTOPTS    64
+#define MASK_ROUTING    32
+#define MASK_FRAGMENT   16
+#define MASK_AH         8
+#define MASK_ESP        4
+#define MASK_NONE       2
+#define MASK_PROTO      1
+
+#endif /*_IP6T_FRAG_H*/