new ip6 FRAG match by kisza

4 files changed, 317 insertions, 0 deletions

diff --git a/extensions/.frag-test6 b/extensions/.frag-test6
new file mode 100755
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
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 8531879..c4f0793 100644
--- 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
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*/