diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set.h	2006-03-13 19:35:38.000000000 +0100
@@ -0,0 +1,316 @@
+#ifndef __NF_SET_H
+#define __NF_SET_H
+
+/* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
+ *                         Patrick Schaaf <bof@bof.de>
+ *                         Martin Josefsson <gandalf@wlug.westbo.se>
+ * Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+#if 1
+#define NF_SET_DEBUG
+#endif
+
+/* Lets work with our own typedef for representing an IP address.
+ * We hope to make the code more portable, possibly to IPv6...
+ *
+ * The representation works in HOST byte order, because most set types
+ * will perform arithmetic operations and compare operations.
+ * 
+ * For now the type is an uint32_t.
+ *
+ * Make sure to ONLY use the functions when translating and parsing
+ * in order to keep the host byte order and make it more portable:
+ *  parse_ip()
+ *  parse_mask()
+ *  parse_ipandmask()
+ *  ip_tostring()
+ * (Joakim: where are they???)
+ */
+
+typedef uint32_t nf_set_ip_t;
+
+/* Sets are identified by an id in kernel space. Tweak with nf_set_id_t
+ * and NF_SET_INVALID_ID if you want to increase the max number of sets.
+ */
+typedef uint16_t nf_set_id_t;
+
+#define NF_SET_INVALID_ID	65535
+
+#define NF_SET_MAXNAMELEN 	32	/* set names and set typenames */
+
+/* Core protocol version */
+#define NF_SET_PROTOCOL_VERSION	1
+
+/*
+ * Option flags for kernel operations (ipt[6]_set_info)
+ */
+#define NFSET_SRC 		0x01	/* Source match/add */
+#define NFSET_DST		0x02	/* Destination match/add */
+#define NFSET_MATCH_INV		0x04	/* Inverse matching */
+
+/* Option flags for userspace operations */
+#define NFSET_IGNORE_ERRORS	0x01	/* Ignore errors at add/del */
+
+/*
+ * Set features
+ */
+#define NFSET_TYPE_IP		0x01	/* IP address type of set */
+#define NFSET_TYPE_IPV4		0x01	/* IP address type of set */
+#define NFSET_TYPE_IPV6		0x02	/* IPv6 address type of set */
+#define NFSET_TYPE_PORT		0x04	/* Port type of set */
+#define NFSET_TYPE_SINGLE	0x08	/* Single data storage */
+#define NFSET_TYPE_DOUBLE	0x10	/* Double data storage */
+
+#define NF_SET_MAX_STORAGE	2	/* Double data storage */
+
+/* Often used routine in bitmap type of sets */
+static inline int bitmap_bytes(nf_set_ip_t a, nf_set_ip_t b)
+{
+	return 4 * ((((b - a + 8) / 8) + 3) / 4);
+}
+
+#ifdef __KERNEL__
+#define nf_set_printk(format, args...) 			\
+	do {							\
+		printk("%s: %s: ", __FILE__, __FUNCTION__);	\
+		printk(format "\n" , ## args);			\
+	} while (0)
+
+#if defined(NF_SET_DEBUG)
+#define DP(format, args...) 					\
+	do {							\
+		printk("%s: %s (DBG): ", __FILE__, __FUNCTION__);\
+		printk(format "\n" , ## args);			\
+	} while (0)
+#define NF_SET_ASSERT(x)					\
+	do {							\
+		if (!(x))					\
+			printk("NF_SET_ASSERT: %s:%i(%s)\n",	\
+				__FILE__, __LINE__, __FUNCTION__); \
+	} while (0)
+#else
+#define DP(format, args...)
+#define NF_SET_ASSERT(x)
+#endif
+
+/* 
+ * Unified set header data 
+ */
+struct nfset_l2proto {
+        unsigned char ethernet[ETH_ALEN];
+};
+
+#define NFSET_FLAG_L2_ETHER	0x00000001
+#define NFSET_FLAG_L2		0x000000ff
+
+struct nfset_l3proto {
+        union {
+                __u32 ipv4;
+                __u32 ipv6[4];
+        } from;        
+        union {
+                __u32 ipv4;
+                __u32 ipv6[4];
+        } to;
+        __u32 mask;
+        __u16 protonum;
+};
+
+#define NFSET_FLAG_L3_FROM	0x00000100
+#define NFSET_FLAG_L3_TO	0x00000200
+#define NFSET_FLAG_L3_MASK	0x00000400
+#define NFSET_FLAG_L3_PROTONUM	0x00000800
+#define NFSET_FLAG_L3		0x0000ff00
+
+struct nfset_l4proto {
+        __u16 from;
+        __u16 to;
+};
+
+#define NFSET_FLAG_L4_FROM	0x00010000
+#define NFSET_FLAG_L4_TO	0x00020000
+#define NFSET_FLAG_L4		0x00ff0000
+
+struct nfset_genproto {
+        __u32 size;
+        __u32 limit;
+        __u32 timeout;
+        __u32 flags;
+};
+
+#define NFSET_FLAG_GEN_SIZE	0x01000000
+#define NFSET_FLAG_GEN_LIMIT	0x02000000
+#define NFSET_FLAG_GEN_TIMEOUT	0x04000000
+#define NFSET_FLAG_GEN_FLAGS	0x08000000
+#define NFSET_FLAG_GEN		0xff000000
+
+struct nfset_proto {
+        __u32 flags;
+        struct nfset_l2proto l2;
+        struct nfset_l3proto l3;
+        struct nfset_l4proto l4;
+        struct nfset_genproto gen;
+};
+
+/*
+ * The nf_set_subtype definition - there can be more per set type.
+ *
+ * Each individual set has a pointer, set->subtype, going to one
+ * of these structures. Function pointers inside the structure implement
+ * the real behaviour of the sets.
+ *
+ * If not mentioned differently, the implementation behind the function
+ * pointers of a set_type, is expected to return 0 if ok, and a negative
+ * errno (e.g. -EINVAL) on error.
+ */
+struct nf_set;
+
+struct nf_set_subtype {
+	/* test for IP in set (kernel: iptables -m set src|dst)
+	 * return 0 if not in set, 1 if in set.
+	 */
+	int (*test_kernel) (struct nf_set *set,
+                            const struct sk_buff * skb,
+                            const u_int32_t *flags);
+
+	/* test for IP in set (userspace: nfset -T set IP)
+	 * return 0 if not in set, 1 if in set.
+	 */
+	int (*test) (struct nf_set *set,
+                     const void *data, size_t size,
+                     const u_int32_t flags);
+
+	/* Add IP into set (userspace: nfset -A set IP)
+	 * Return -EEXIST if the address is already in the set,
+	 * and -ERANGE if the address lies outside the set bounds.
+	 * If the address was not already in the set, 0 is returned.
+	 */
+	int (*add) (struct nf_set *set, 
+                    const void *data, size_t size,
+                    const u_int32_t flags);
+
+	/* Add IP into set (kernel: iptables ... -j SET set src|dst)
+	 * Return -EEXIST if the address is already in the set,
+	 * and -ERANGE if the address lies outside the set bounds.
+	 * If the address was not already in the set, 0 is returned.
+	 */
+	int (*add_kernel) (struct nf_set *set,
+                           const struct sk_buff * skb,
+                           const u_int32_t *flags);
+
+	/* remove IP from set (userspace: nfset -D set x)
+	 * Return -EEXIST if the address is NOT in the set,
+	 * and -ERANGE if the address lies outside the set bounds.
+	 * If the address really was in the set, 0 is returned.
+	 */
+	int (*del) (struct nf_set *set, 
+                    const void *data, size_t size,
+                    const u_int32_t flags);
+
+	/* remove IP from set (kernel: iptables ... -j SET set src)
+	 * Return -EEXIST if the address is NOT in the set,
+	 * and -ERANGE if the address lies outside the set bounds.
+	 * If the address really was in the set, 0 is returned.
+	 */
+	int (*del_kernel) (struct nf_set *set,
+                           const struct sk_buff * skb,
+                           const u_int32_t *flags);
+
+	/* new set creation - allocated type specific items
+	 */
+	int (*create) (struct nf_set *set,
+		       const struct nfset_proto *proto);
+
+	/* set destruction - free type specific items
+	 * There is no return value.
+	 * Can be called only when child sets are destroyed.
+	 */
+	void (*destroy) (struct nf_set *set);
+
+	/* set flushing - reset all bits in the set, or something similar.
+	 * There is no return value.
+	 */
+	void (*flush) (struct nf_set *set);
+
+	/* Listing: Get the header
+	 *
+	 * Fill in the information in "data".
+	 * This function is always run after list_header_size() under a 
+	 * writelock on the set. Therefor is the length of "data" always 
+	 * correct. 
+	 */
+	void (*list_header) (const struct nf_set *set, 
+			     struct nfset_proto *data);
+
+	/* Listing: Get the set members
+	 *
+	 * Fill in the information in "data".
+	 * This function is always run after list_member_size() under a 
+	 * writelock on the set. Therefor is the length of "data" always 
+	 * correct. 
+	 */
+	int (*list_members) (const struct nf_set *set,
+			      void *buffer, int buflen,
+			      long args[5]);
+        
+        /* Subtype creation flags */
+        __u32 flags;
+};
+
+struct nf_set_type {
+	struct list_head list;	/* next in list of set types */
+
+	char typename[NF_SET_MAXNAMELEN];	/* Type name */
+	unsigned int protocol_version;		/* Core protocol version */
+	unsigned char features;			/* NFSET_TYPE_* features */
+	unsigned int subtype_base;		/* Base index of subtypes */
+	unsigned int subtype_next;		/* Next unused subtype index */
+	struct module *me;			/* module pointer */
+
+	struct nf_set_subtype subtypes[1];	/* The subtypes or versions */
+};
+
+/* A generic nfset */
+struct nf_set {
+	char name[NF_SET_MAXNAMELEN];	/* the name of the set */
+	rwlock_t lock;			/* lock for concurrency control */
+	nf_set_id_t id;			/* set id for swapping */
+	atomic_t ref;			/* in kernel references */
+	struct nf_set_type *type; 	/* the set type */
+	struct nf_set_subtype *subtype; /* the set subtype */
+	void *data;			/* set subtype specific data */
+};
+
+/* set type management */
+extern int nf_set_register_set_type(struct nf_set_type *set_type);
+extern void nf_set_unregister_set_type(struct nf_set_type *set_type);
+
+/* get and put sets */
+extern nf_set_id_t nf_set_get_byname(const char name[NF_SET_MAXNAMELEN]);
+extern void nf_set_put_byindex(nf_set_id_t id);
+
+/* slab cache management */
+extern int nf_set_cache_create(size_t size, unsigned int *id);
+extern void nf_set_cache_destroy(unsigned int id);
+extern void * nf_set_cache_alloc(unsigned int id, gfp_t flags);
+extern void nf_set_cache_free(unsigned int id, void *data);
+
+/* API for ip[6]tables set match, and SET target */
+extern void nf_set_add_kernel(nf_set_id_t index,
+                              const struct sk_buff *skb,
+                              const u_int32_t *flags);
+extern void nf_set_del_kernel(nf_set_id_t index,
+                              const struct sk_buff *skb,
+                              const u_int32_t *flags);
+extern int nf_set_test_kernel(nf_set_id_t index,
+                              const struct sk_buff *skb,
+                              const u_int32_t *flags);
+
+#endif				/* __KERNEL__ */
+
+#endif /*__NF_SET_H*/
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_iphash.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_iphash.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_iphash.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_iphash.h	2006-03-09 16:12:23.000000000 +0100
@@ -0,0 +1,15 @@
+#ifndef __NF_SET_IPHASH_H
+#define __NF_SET_IPHASH_H
+
+#include <linux/netfilter/nf_set.h>
+#include <linux/netfilter/nf_set_iphash_common.h>
+
+#define SETTYPE_NAME "iphash"
+#define MAX_RANGE 0x0000FFFF
+
+struct nf_set_iphash {
+	nf_set_ip_t netmask;		/* netmask */
+	struct __nf_set_iphash map;	/* common iphash type of map */ 
+};
+
+#endif	/* __NF_SET_IPHASH_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_iphash_common.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_iphash_common.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_iphash_common.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_iphash_common.h	2006-03-13 19:23:29.000000000 +0100
@@ -0,0 +1,223 @@
+#ifndef __NF_SET_IPHASH_COMMON_H
+#define __NF_SET_IPHASH_COMMON_H
+
+#include <linux/netfilter/nf_set.h>
+
+#if BITS_PER_LONG < 64
+#define IPHASH_LEN	3
+#else
+#define IPHASH_LEN	4
+#endif
+
+struct iphash {
+	struct iphash *next;
+	nf_set_ip_t ip[IPHASH_LEN];
+};
+
+struct __nf_set_iphash {
+	uint32_t hashsize;		/* hash size */
+	uint32_t limit;			/* max number of IP addresses */
+	uint32_t count;			/* current number of IP addresses */
+	uint32_t initval;		/* initval for jhash_1word */
+	struct iphash *members[0];	/* the iphash proper */
+};
+
+#ifdef __KERNEL__
+static inline int
+__iphash_testip(struct __nf_set_iphash *map, nf_set_ip_t ip)
+{
+	struct iphash *elem;
+	__u32 id;
+	int i;
+
+	id = jhash_1word(ip, map->initval) % map->hashsize;
+	DP("hash key: %u", id);
+	elem = map->members[id];
+	while (elem) {
+		DP("try bucket %p", elem);
+		for (i = 0; i < IPHASH_LEN; i++)
+			if (elem->ip[i] == ip) {
+				DP("found at %u", i);
+				return 1;
+			}
+		elem = elem->next;
+	}
+	return 0;
+}
+
+static inline struct iphash *
+__iphash_iphash_alloc(unsigned int cache_id)
+{
+	struct iphash *elem = (struct iphash *)
+		nf_set_cache_alloc(cache_id, GFP_ATOMIC);
+	
+	if (elem)
+		memset(elem, 0, sizeof(struct iphash));
+	
+	return elem;
+}
+
+static inline int
+__iphash_addip(unsigned int cache_id, 
+	       struct __nf_set_iphash *map, nf_set_ip_t ip)
+{
+	struct iphash *elem;
+	__u32 id;
+	int i;
+
+	if (map->count >= map->limit)
+		return -EOVERFLOW;
+	
+	id = jhash_1word(ip, map->initval) % map->hashsize;
+	DP("hash key: %u", id);
+	if (!map->members[id]) {
+		map->members[id] = __iphash_iphash_alloc(cache_id);
+		if (!map->members[id])
+			return -ENOMEM;
+		DP("create bucket %u (%p)", id, map->members[id]);
+	}
+	elem = map->members[id];
+	while (1) {
+		for (i = 0; i < IPHASH_LEN; i++) {
+			if (elem->ip[i] == ip)
+				return -EEXIST;
+			if (!elem->ip[i]) {
+				elem->ip[i] = ip;
+				map->count++;
+				return 0;
+			}
+		}
+		if (!elem->next) {
+			elem->next = __iphash_iphash_alloc(cache_id);
+			if (!elem->next)
+				return -ENOMEM;
+			DP("create elem %p", elem->next);
+		}
+		elem = elem->next;
+	}
+	return 0;
+}
+
+static inline struct iphash *
+find_last(struct iphash *elem, int *i)
+{
+	struct iphash *prev;
+	
+	if (!elem->next)
+		return NULL;
+		
+	while (elem->next) {
+		prev = elem;
+		elem = elem->next;
+	}
+		
+	for (*i = IPHASH_LEN - 1; *i >= 0; (*i)--) {
+		if (elem->ip[*i])
+			return prev;
+	}
+	BUG();
+	return NULL;
+}
+
+static inline int
+__iphash_delip(unsigned int cache_id,
+	       struct __nf_set_iphash *map, nf_set_ip_t ip)
+{
+	struct iphash *elem, *prev, *pprev;
+	__u32 id;
+	int i, j;
+
+	id = jhash_1word(ip, map->initval) % map->hashsize;
+	DP("hash key: %u", id);
+	prev = elem = map->members[id];
+	while (elem) {
+		for (i = 0; i < IPHASH_LEN; i++) {
+			if (elem->ip[i] == ip) {
+				DP("found at %u", i);
+				map->count--;
+				pprev = find_last(elem, &j);
+				if (pprev) {
+					DP("found prev %p", pprev);
+					elem->ip[i] = pprev->next->ip[j];
+					pprev->next->ip[j] = 0;
+					prev = pprev;
+					elem = prev->next;
+				} else
+					elem->ip[i] = 0;
+
+				for (j = 0, i = 0; i < IPHASH_LEN; i++)
+					if (!elem->ip[i])
+						j++;
+				if (j == IPHASH_LEN) {
+					DP("freeing %p", elem);
+					if (elem == map->members[id])
+						map->members[id] = NULL;
+					else
+						prev->next = NULL;
+
+					nf_set_cache_free(cache_id, elem);
+				}
+				return 0;
+			}
+		}
+		prev = elem;
+		elem = elem->next;
+	}
+	return -EEXIST;
+}
+
+static inline void 
+__iphash_destroy(unsigned int cache_id, struct __nf_set_iphash *map)
+{
+	struct iphash *elem, *tmp;
+	uint32_t i;
+
+	for (i = 0; i < map->hashsize; i++) {
+		elem = map->members[i];
+		while (elem) {
+			tmp = elem->next;
+			nf_set_cache_free(cache_id, elem);
+			elem = tmp;
+		}
+	}
+}
+
+static inline void 
+__iphash_flush(unsigned int cache_id, struct __nf_set_iphash *map)
+{
+	struct iphash *elem, *tmp;
+	uint32_t i;
+
+	for (i = 0; i < map->hashsize; i++) {
+		elem = map->members[i];
+		while (elem) {
+			tmp = elem->next;
+			nf_set_cache_free(cache_id, elem);
+			elem = tmp;
+		}
+		map->members[i] = NULL;
+	}
+	map->count = 0;
+}
+
+static inline void 
+__iphash_list_members(const struct __nf_set_iphash *map, void *data)
+{
+	struct iphash *elem;
+	nf_set_ip_t i, k;
+	int j;
+
+	k = 0;
+	for (i = 0;  i < map->hashsize; i++) {
+		elem = map->members[i];
+		while (elem) {
+			for (j = 0; j < IPHASH_LEN; j++)
+				if (elem->ip[j])
+					((nf_set_ip_t *)data)[k++] =
+						elem->ip[j];
+			elem = elem->next;
+		}
+	}
+}
+#endif /* __KERNEL__ */
+#endif /* __NF_SET_IPHASH_COMMON_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_ipmap.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_ipmap.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_ipmap.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_ipmap.h	2006-03-08 23:23:50.000000000 +0100
@@ -0,0 +1,56 @@
+#ifndef __NF_SET_IPMAP_H
+#define __NF_SET_IPMAP_H
+
+#include <linux/netfilter/nf_set.h>
+
+#define SETTYPE_NAME "ipmap"
+#define MAX_RANGE 0x0000FFFF
+
+struct nf_set_ipmap {
+	void *members;			/* the ipmap proper */
+	nf_set_ip_t first_ip;		/* host byte order, included in range */
+	nf_set_ip_t last_ip;		/* host byte order, included in range */
+	nf_set_ip_t netmask;		/* subnet netmask */
+	nf_set_ip_t sizeid;		/* size of set in IPs */
+	nf_set_ip_t hosts;		/* number of hosts in a subnet */
+};
+
+struct nf_set_req_ipmap_create {
+	nf_set_ip_t from;
+	nf_set_ip_t to;
+	nf_set_ip_t netmask;
+};
+
+struct nf_set_req_ipmap {
+	nf_set_ip_t ip;
+};
+
+unsigned int
+mask_to_bits(nf_set_ip_t mask)
+{
+	unsigned int bits = 32;
+	nf_set_ip_t maskaddr;
+	
+	if (mask == 0xFFFFFFFF)
+		return bits;
+	
+	maskaddr = 0xFFFFFFFE;
+	while (--bits >= 0 && maskaddr != mask)
+		maskaddr <<= 1;
+	
+	return bits;
+}
+
+nf_set_ip_t
+range_to_mask(nf_set_ip_t from, nf_set_ip_t to, unsigned int *bits)
+{
+	nf_set_ip_t mask = 0xFFFFFFFE;
+	
+	*bits = 32;
+	while (--(*bits) >= 0 && mask && (to & mask) != from)
+		mask <<= 1;
+		
+	return mask;
+}
+	
+#endif /* __NF_SET_IPMAP_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_ipporthash.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_ipporthash.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_ipporthash.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_ipporthash.h	2006-03-08 23:24:12.000000000 +0100
@@ -0,0 +1,29 @@
+#ifndef __NF_SET_IPPORTHASH_H
+#define __NF_SET_IPPORTHASH_H
+
+#include <linux/netfilter/nf_set.h>
+#include <linux/netfilter/nf_set_iphash_common.h>
+
+#define SETTYPE_NAME "ipporthash"
+#define MAX_RANGE 0x0000FFFF
+#define INVALID_PORT	(MAX_RANGE + 1)
+
+struct nf_set_ipporthash {
+	nf_set_ip_t first_ip;		/* host byte order, included in range */
+	nf_set_ip_t last_ip;		/* host byte order, included in range */
+	struct __nf_set_iphash map;	/* common iphash type of map */ 
+};
+
+struct nf_set_req_ipporthash_create {
+	uint32_t hashsize;
+	uint32_t limit;
+	nf_set_ip_t from;
+	nf_set_ip_t to;
+};
+
+struct nf_set_req_ipporthash {
+	nf_set_ip_t ip;
+	nf_set_ip_t port;
+};
+
+#endif	/* __NF_SET_IPPORTHASH_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_iptree.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_iptree.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_iptree.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_iptree.h	2006-03-08 23:24:51.000000000 +0100
@@ -0,0 +1,42 @@
+#ifndef __NF_SET_IPTREE_H
+#define __NF_SET_IPTREE_H
+
+#include <linux/netfilter/nf_set.h>
+
+#define SETTYPE_NAME "iptree"
+#define MAX_RANGE 0x0000FFFF
+
+struct nf_set_iptreed {
+	unsigned long expires[256];	   	/* x.x.x.ADDR */
+};
+
+struct nf_set_iptreec {
+	struct nf_set_iptreed *tree[256];	/* x.x.ADDR.* */
+};
+
+struct nf_set_iptreeb {
+	struct nf_set_iptreec *tree[256];	/* x.ADDR.*.* */
+};
+
+struct nf_set_iptree {
+	uint32_t limit;			/* max number of IP addresses */
+	uint32_t count;			/* current number of IP addresses */
+	unsigned int timeout;
+	unsigned int gc_interval;
+#ifdef __KERNEL__
+	struct timer_list gc;
+	struct nf_set_iptreeb *tree[256];	/* ADDR.*.*.* */
+#endif
+};
+
+struct nf_set_req_iptree_create {
+	nf_set_ip_t limit;
+	unsigned int timeout;
+};
+
+struct nf_set_req_iptree {
+	nf_set_ip_t ip;
+	unsigned int timeout;
+};
+
+#endif	/* __NF_SET_IPTREE_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_jhash.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_jhash.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_jhash.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_jhash.h	2006-03-08 17:02:59.000000000 +0100
@@ -0,0 +1,148 @@
+#ifndef _NF_SET_JHASH_H
+#define _NF_SET_JHASH_H
+
+/* This is a copy of linux/jhash.h but the types u32/u8 are changed
+ * to __u32/__u8 so that the header file can be included into
+ * userspace code as well. Jozsef Kadlecsik (kadlec@blackhole.kfki.hu)
+ */
+
+/* jhash.h: Jenkins hash support.
+ *
+ * Copyright (C) 1996 Bob Jenkins (bob_jenkins@burtleburtle.net)
+ *
+ * http://burtleburtle.net/bob/hash/
+ *
+ * These are the credits from Bob's sources:
+ *
+ * lookup2.c, by Bob Jenkins, December 1996, Public Domain.
+ * hash(), hash2(), hash3, and mix() are externally useful functions.
+ * Routines to test the hash are included if SELF_TEST is defined.
+ * You can use this free for any purpose.  It has no warranty.
+ *
+ * Copyright (C) 2003 David S. Miller (davem@redhat.com)
+ *
+ * I've modified Bob's hash to be useful in the Linux kernel, and
+ * any bugs present are surely my fault.  -DaveM
+ */
+
+/* NOTE: Arguments are modified. */
+#define __jhash_mix(a, b, c) \
+{ \
+  a -= b; a -= c; a ^= (c>>13); \
+  b -= c; b -= a; b ^= (a<<8); \
+  c -= a; c -= b; c ^= (b>>13); \
+  a -= b; a -= c; a ^= (c>>12);  \
+  b -= c; b -= a; b ^= (a<<16); \
+  c -= a; c -= b; c ^= (b>>5); \
+  a -= b; a -= c; a ^= (c>>3);  \
+  b -= c; b -= a; b ^= (a<<10); \
+  c -= a; c -= b; c ^= (b>>15); \
+}
+
+/* The golden ration: an arbitrary value */
+#define JHASH_GOLDEN_RATIO	0x9e3779b9
+
+/* The most generic version, hashes an arbitrary sequence
+ * of bytes.  No alignment or length assumptions are made about
+ * the input key.
+ */
+static inline __u32 jhash(void *key, __u32 length, __u32 initval)
+{
+	__u32 a, b, c, len;
+	__u8 *k = key;
+
+	len = length;
+	a = b = JHASH_GOLDEN_RATIO;
+	c = initval;
+
+	while (len >= 12) {
+		a += (k[0] +((__u32)k[1]<<8) +((__u32)k[2]<<16) +((__u32)k[3]<<24));
+		b += (k[4] +((__u32)k[5]<<8) +((__u32)k[6]<<16) +((__u32)k[7]<<24));
+		c += (k[8] +((__u32)k[9]<<8) +((__u32)k[10]<<16)+((__u32)k[11]<<24));
+
+		__jhash_mix(a,b,c);
+
+		k += 12;
+		len -= 12;
+	}
+
+	c += length;
+	switch (len) {
+	case 11: c += ((__u32)k[10]<<24);
+	case 10: c += ((__u32)k[9]<<16);
+	case 9 : c += ((__u32)k[8]<<8);
+	case 8 : b += ((__u32)k[7]<<24);
+	case 7 : b += ((__u32)k[6]<<16);
+	case 6 : b += ((__u32)k[5]<<8);
+	case 5 : b += k[4];
+	case 4 : a += ((__u32)k[3]<<24);
+	case 3 : a += ((__u32)k[2]<<16);
+	case 2 : a += ((__u32)k[1]<<8);
+	case 1 : a += k[0];
+	};
+
+	__jhash_mix(a,b,c);
+
+	return c;
+}
+
+/* A special optimized version that handles 1 or more of __u32s.
+ * The length parameter here is the number of __u32s in the key.
+ */
+static inline __u32 jhash2(__u32 *k, __u32 length, __u32 initval)
+{
+	__u32 a, b, c, len;
+
+	a = b = JHASH_GOLDEN_RATIO;
+	c = initval;
+	len = length;
+
+	while (len >= 3) {
+		a += k[0];
+		b += k[1];
+		c += k[2];
+		__jhash_mix(a, b, c);
+		k += 3; len -= 3;
+	}
+
+	c += length * 4;
+
+	switch (len) {
+	case 2 : b += k[1];
+	case 1 : a += k[0];
+	};
+
+	__jhash_mix(a,b,c);
+
+	return c;
+}
+
+
+/* A special ultra-optimized versions that knows they are hashing exactly
+ * 3, 2 or 1 word(s).
+ *
+ * NOTE: In partilar the "c += length; __jhash_mix(a,b,c);" normally
+ *       done at the end is not done here.
+ */
+static inline __u32 jhash_3words(__u32 a, __u32 b, __u32 c, __u32 initval)
+{
+	a += JHASH_GOLDEN_RATIO;
+	b += JHASH_GOLDEN_RATIO;
+	c += initval;
+
+	__jhash_mix(a, b, c);
+
+	return c;
+}
+
+static inline __u32 jhash_2words(__u32 a, __u32 b, __u32 initval)
+{
+	return jhash_3words(a, b, 0, initval);
+}
+
+static inline __u32 jhash_1word(__u32 a, __u32 initval)
+{
+	return jhash_3words(a, 0, 0, initval);
+}
+
+#endif /* _NF_SET_JHASH_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_macipmap.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_macipmap.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_macipmap.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_macipmap.h	2006-03-08 23:25:22.000000000 +0100
@@ -0,0 +1,38 @@
+#ifndef __NF_SET_MACIPMAP_H
+#define __NF_SET_MACIPMAP_H
+
+#include <linux/netfilter/nf_set.h>
+
+#define SETTYPE_NAME "macipmap"
+#define MAX_RANGE 0x0000FFFF
+
+/* general flags */
+#define IPSET_MACIP_MATCHUNSET	1
+
+/* per ip flags */
+#define IPSET_MACIP_ISSET	1
+
+struct nf_set_macipmap {
+	void *members;			/* the macipmap proper */
+	nf_set_ip_t first_ip;		/* host byte order, included in range */
+	nf_set_ip_t last_ip;		/* host byte order, included in range */
+	u_int32_t flags;
+};
+
+struct nf_set_req_macipmap_create {
+	nf_set_ip_t from;
+	nf_set_ip_t to;
+	u_int32_t flags;
+};
+
+struct nf_set_req_macipmap {
+	nf_set_ip_t ip;
+	unsigned char ethernet[ETH_ALEN];
+};
+
+struct nf_set_macip {
+	unsigned short flags;
+	unsigned char ethernet[ETH_ALEN];
+};
+
+#endif	/* __NF_SET_MACIPMAP_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_malloc.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_malloc.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_malloc.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_malloc.h	2006-03-08 17:33:42.000000000 +0100
@@ -0,0 +1,33 @@
+#ifndef __NF_SET_MALLOC_H
+#define __NF_SET_MALLOC_H
+
+#ifdef __KERNEL__
+
+/* Memory allocation and deallocation */
+static size_t max_malloc_size = 0;
+
+static inline void init_max_malloc_size(void)
+{
+#define CACHE(x) max_malloc_size = x;
+#include <linux/kmalloc_sizes.h>
+#undef CACHE
+}
+
+static inline void * nf_set_malloc(size_t bytes, gfp_t flags)
+{
+	if (bytes > max_malloc_size)
+		return vmalloc(bytes);
+	else
+		return kmalloc(bytes, flags);
+}
+
+static inline void nf_set_free(void * data, size_t bytes)
+{
+	if (bytes > max_malloc_size)
+		vfree(data);
+	else
+		kfree(data);
+}
+#endif				/* __KERNEL__ */
+
+#endif /*__NF_SET_MALLOC_H*/
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_nethash.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_nethash.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_nethash.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_nethash.h	2006-03-08 23:25:52.000000000 +0100
@@ -0,0 +1,54 @@
+#ifndef __NF_SET_NETHASH_H
+#define __NF_SET_NETHASH_H
+
+#include <linux/netfilter/nf_set.h>
+
+#define SETTYPE_NAME "nethash"
+#define MAX_RANGE 0x0000FFFF
+
+struct nf_set_nethash {
+	nf_set_ip_t *members;		/* the nethash proper */
+	uint32_t hashsize;		/* hash size */
+	uint16_t probes;		/* max number of probes  */
+	uint16_t resize;		/* resize factor in percent */
+	unsigned char cidr[30];		/* CIDR sizes */
+	void *initval[0];		/* initvals for jhash_1word */
+};
+
+struct nf_set_req_nethash_create {
+	uint32_t hashsize;
+	uint16_t probes;
+	uint16_t resize;
+};
+
+struct nf_set_req_nethash {
+	nf_set_ip_t ip;
+	unsigned char cidr;
+};
+
+static unsigned char shifts[] = {255, 253, 249, 241, 225, 193, 129, 1};
+
+static inline nf_set_ip_t 
+pack(nf_set_ip_t ip, unsigned char cidr)
+{
+	nf_set_ip_t addr, *paddr = &addr;
+	unsigned char n, t, *a;
+
+	addr = htonl(ip & (0xFFFFFFFF << (32 - (cidr))));
+#ifdef __KERNEL__
+	DP("ip:%u.%u.%u.%u/%u", NIPQUAD(addr), cidr);
+#endif
+	n = cidr / 8;
+	t = cidr % 8;	
+	a = &((unsigned char *)paddr)[n];
+	*a = *a /(1 << (8 - t)) + shifts[t];
+#ifdef __KERNEL__
+	DP("n: %u, t: %u, a: %u", n, t, *a);
+	DP("ip:%u.%u.%u.%u/%u, %u.%u.%u.%u",
+	   HIPQUAD(ip), cidr, NIPQUAD(addr));
+#endif
+
+	return ntohl(addr);
+}
+
+#endif	/* __NF_SET_NETHASH_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nf_set_portmap.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_portmap.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nf_set_portmap.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nf_set_portmap.h	2006-03-08 23:26:07.000000000 +0100
@@ -0,0 +1,25 @@
+#ifndef __NF_SET_PORTMAP_H
+#define __NF_SET_PORTMAP_H
+
+#include <linux/netfilter/nf_set.h>
+
+#define SETTYPE_NAME	"portmap"
+#define MAX_RANGE	0x0000FFFF
+#define INVALID_PORT	(MAX_RANGE + 1)
+
+struct nf_set_portmap {
+	void *members;			/* the portmap proper */
+	nf_set_ip_t first_port;		/* host byte order, included in range */
+	nf_set_ip_t last_port;		/* host byte order, included in range */
+};
+
+struct nf_set_req_portmap_create {
+	nf_set_ip_t from;
+	nf_set_ip_t to;
+};
+
+struct nf_set_req_portmap {
+	nf_set_ip_t port;
+};
+
+#endif /* __NF_SET_PORTMAP_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nfnetlink.h linux-2.6.15.3-nfset/include/linux/netfilter/nfnetlink.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nfnetlink.h	2006-02-07 00:36:47.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nfnetlink.h	2006-03-13 13:24:08.000000000 +0100
@@ -101,7 +101,8 @@
 #define NFNL_SUBSYS_CTNETLINK_EXP	2
 #define NFNL_SUBSYS_QUEUE		3
 #define NFNL_SUBSYS_ULOG		4
-#define NFNL_SUBSYS_COUNT		5
+#define NFNL_SUBSYS_SET			5
+#define NFNL_SUBSYS_COUNT		6
 
 #ifdef __KERNEL__
 
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter/nfnetlink_set.h linux-2.6.15.3-nfset/include/linux/netfilter/nfnetlink_set.h
--- linux-2.6.15.3-orig/include/linux/netfilter/nfnetlink_set.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter/nfnetlink_set.h	2006-03-13 18:02:17.000000000 +0100
@@ -0,0 +1,128 @@
+#ifndef _NFNETLINK_SET_H
+#define _NFNETLINK_SET_H
+
+enum nfset_msg_types {
+	NLSET_OP_CREATE,	/* Create a new (empty) set */
+	NLSET_OP_DESTROY,	/* Remove a (empty) set */
+	NLSET_OP_FLUSH,		/* Remove all elements from a set */
+	NLSET_OP_RENAME,	/* Rename a set */
+	NLSET_OP_SWAP,		/* Swap two sets */
+
+	NLSET_OP_ADT_GET,	/* Get set and type */
+	NLSET_OP_ADD,		/* Add element(s) to a set */
+	NLSET_OP_DEL,		/* Remove element(s) from a set */
+	NLSET_OP_TEST,		/* Test an element in a set */
+
+	NLSET_OP_LIST,		/* List all sets */
+	NLSET_OP_LIST_SET,	/* List a set */
+	NLSET_OP_STATS,		/* Get set stats */
+
+	NLSET_MSG_MAX
+};
+
+/* Main attributes: create */
+enum nfset_attr_set_create_type {
+	NFSET_CREATE_UNSPEC,
+	NFSET_CREATE_NAME,		/* Name of the set */
+	NFSET_CREATE_TYPENAME,		/* Type name of the set */
+	NFSET_CREATE_SUBTYPE,		/* Subtype version */
+	NFSET_CREATE_DATA,		/* Data: type specific data */
+	__NFSET_CREATE_MAX
+};
+#define NFSET_CREATE_MAX (__NFSET_CREATE_MAX - 1)
+
+/* Set header data (create/list): */
+enum nfset_attr_info_type {
+	NFSET_ATTR_HEADER_UNSPEC,
+	NFSET_ATTR_HEADER_GENERAL,	/* General params */
+	NFSET_ATTR_HEADER_L2DATA,	/* Layer 2 data */
+	NFSET_ATTR_HEADER_L3DATA,	/* Layer 3 data */
+	NFSET_ATTR_HEADER_L4DATA,	/* Layer 4 data */
+	__NFSET_ATTR_HEADER_MAX
+};
+#define NFSET_ATTR_HEADER_MAX (__NFSET_ATTR_HEADER_MAX - 1)
+
+enum nfset_attr_general_data_type {
+	NFSET_ATTR_GENERAL_UNSPEC,
+	NFSET_ATTR_GENERAL_SIZE,	/* Hash size */
+	NFSET_ATTR_GENERAL_LIMIT,	/* Limit number of elements */
+	NFSET_ATTR_GENERAL_TIMEOUT,	/* Timeout parameter */
+	NFSET_ATTR_GENERAL_FLAGS,	/* Set specific create flags */
+	__NFSET_ATTR_GENERAL_MAX
+};
+#define NFSET_ATTR_GENERAL_MAX (__NFSET_ATTR_GENERAL_MAX - 1)
+
+enum nfset_attr_layer2_data_type {
+	NFSET_ATTR_L2_UNSPEC,
+	NFSET_ATTR_L2_ETHERNET,		/* MAC or hardware address */
+	__NFSET_ATTR_L2_MAX
+};
+#define NFSET_ATTR_L2_MAX (__NFSET_ATTR_L2_MAX - 1)
+
+enum nfset_attr_layer3_data_type {
+	NFSET_ATTR_L3_UNSPEC,
+	NFSET_ATTR_L3_PROTONUM,		/* protocol family */
+	NFSET_ATTR_L3_IPV4_FROM,	/* IPv4 from address */
+	NFSET_ATTR_L3_IPV4_TO,		/* IPv4 to address */
+	NFSET_ATTR_L3_IPV6_FROM,	/* IPv6 from address */
+	NFSET_ATTR_L3_IPV6_TO,		/* IPv6 to address */
+	NFSET_ATTR_L3_MASK,		/* IPv4/IPv6 netmask */
+	__NFSET_ATTR_L3_MAX
+};
+#define NFSET_ATTR_L3_MAX (__NFSET_ATTR_L3_MAX - 1)
+
+enum nfset_attr_layer4_data_type {
+	NFSET_ATTR_L4_UNSPEC,
+	NFSET_ATTR_L4_FROM,		/* From port */
+	NFSET_ATTR_L4_TO,		/* To port */
+	__NFSET_ATTR_L4_MAX
+};
+#define NFSET_ATTR_L4_MAX (__NFSET_ATTR_L4_MAX - 1)
+
+/* Main attributes: destroy, flush, adt_get, list */
+enum nfset_attr_set_list_type {
+	NFSET_LIST_UNSPEC,
+	NFSET_LIST_NAME,	/* Name of the set */
+	__NFSET_LIST_MAX
+};
+#define NFSET_LIST_MAX (__NFSET_LIST_MAX - 1)
+
+/* Main attributes: list_members */
+enum nfset_attr_set_list_data_type {
+	NFSET_LIST_DATA_UNSPEC,
+	NFSET_LIST_DATA,	/* Members data */
+	__NFSET_LIST_DATA_MAX
+};
+#define NFSET_LIST_DATA_MAX (__NFSET_LIST_DATA_MAX - 1)
+
+/* Main attributes: rename, swap */
+enum nfset_attr_set_rename_type {
+	NFSET_RENAME_UNSPEC,
+	NFSET_RENAME_FROM,	/* From name */
+	NFSET_RENAME_TO,	/* To name */
+	__NFSET_RENAME_MAX
+};
+#define NFSET_RENAME_MAX (__NFSET_RENAME_MAX - 1)
+
+/* Main attributes: adt */
+enum nfset_attr_set_adt_type {
+	NFSET_ADT_UNSPEC,
+	NFSET_ADT_ID,		/* Set id */
+	NFSET_ADT_FLAGS,	/* Flags for add/del/test */
+	NFSET_ADT_DATA,		/* Set specific data */
+	__NFSET_ADT_MAX
+};
+#define NFSET_ADT_MAX (__NFSET_ADT_MAX - 1)
+
+/* Main attributes: reply to adt_get */
+enum nfset_attr_set_get_type {
+	NFSET_GET_UNSPEC,
+	NFSET_GET_ID,		/* Set id */
+	NFSET_GET_TYPENAME,	/* Settype name */
+	NFSET_GET_SUBTYPE_BASE,	/* Base of supported subtypes */
+	NFSET_GET_SUBTYPE_NEXT,	/* Next, unsupported subtype */
+	__NFSET_GET_MAX
+};
+#define NFSET_GET_MAX (__NFSET_GET_MAX - 1)
+
+#endif /* _NFNETLINK_SET_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/include/linux/netfilter_ipv4/ipt_set.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ipt_set.h
--- linux-2.6.15.3-orig/include/linux/netfilter_ipv4/ipt_set.h	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ipt_set.h	2006-03-13 13:18:31.000000000 +0100
@@ -0,0 +1,23 @@
+#ifndef _IPT_SET_H
+#define _IPT_SET_H
+
+#include <linux/netfilter/nf_set.h>
+
+struct ipt_set_info {
+	char name[NF_SET_MAXNAMELEN];
+	nf_set_id_t index;
+	u_int32_t flags[NF_SET_MAX_STORAGE + 1];
+};
+
+/* match info */
+struct ipt_set_info_match {
+	struct ipt_set_info match_set;
+};
+
+/* target info */
+struct ipt_set_info_target {
+	struct ipt_set_info add_set;
+	struct ipt_set_info del_set;
+};
+
+#endif /*_IPT_SET_H*/
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/ipv4/netfilter/Kconfig linux-2.6.15.3-nfset/net/ipv4/netfilter/Kconfig
--- linux-2.6.15.3-orig/net/ipv4/netfilter/Kconfig	2006-02-07 00:36:47.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/Kconfig	2006-03-09 10:22:11.000000000 +0100
@@ -842,5 +842,25 @@
 	  Allows altering the ARP packet payload: source and destination
 	  hardware and network addresses.
 
+config IP_NF_MATCH_SET
+	tristate "set match support"
+	depends on NF_SET
+	help
+	  Set matching matches against given IP sets.
+	  You need the nfset utility to create and set up the sets.
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
+config IP_NF_TARGET_SET
+	tristate "SET target support"
+	depends on NF_SET
+	help
+	  The SET target makes possible to add/delete entries
+	  in IP sets.
+	  You need the nfset utility to create and set up the sets.
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
+
 endmenu
 
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/ipv4/netfilter/Makefile linux-2.6.15.3-nfset/net/ipv4/netfilter/Makefile
--- linux-2.6.15.3-orig/net/ipv4/netfilter/Makefile	2006-02-07 00:36:47.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/Makefile	2006-03-08 15:48:16.000000000 +0100
@@ -52,6 +52,7 @@
 obj-$(CONFIG_IP_NF_MATCH_SCTP) += ipt_sctp.o
 obj-$(CONFIG_IP_NF_MATCH_DCCP) += ipt_dccp.o
 obj-$(CONFIG_IP_NF_MATCH_MARK) += ipt_mark.o
+obj-$(CONFIG_IP_NF_MATCH_SET) += ipt_set.o
 obj-$(CONFIG_IP_NF_MATCH_MAC) += ipt_mac.o
 obj-$(CONFIG_IP_NF_MATCH_IPRANGE) += ipt_iprange.o
 obj-$(CONFIG_IP_NF_MATCH_PKTTYPE) += ipt_pkttype.o
@@ -92,6 +93,7 @@
 obj-$(CONFIG_IP_NF_TARGET_ULOG) += ipt_ULOG.o
 obj-$(CONFIG_IP_NF_TARGET_TCPMSS) += ipt_TCPMSS.o
 obj-$(CONFIG_IP_NF_TARGET_NOTRACK) += ipt_NOTRACK.o
+obj-$(CONFIG_IP_NF_TARGET_SET) += ipt_SET.o
 obj-$(CONFIG_IP_NF_TARGET_CLUSTERIP) += ipt_CLUSTERIP.o
 obj-$(CONFIG_IP_NF_TARGET_TTL) += ipt_TTL.o
 obj-$(CONFIG_IP_NF_TARGET_NFQUEUE) += ipt_NFQUEUE.o
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/ipv4/netfilter/ipt_SET.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ipt_SET.c
--- linux-2.6.15.3-orig/net/ipv4/netfilter/ipt_SET.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ipt_SET.c	2006-03-13 13:22:06.000000000 +0100
@@ -0,0 +1,122 @@
+/* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
+ *                         Patrick Schaaf <bof@bof.de>
+ *                         Martin Josefsson <gandalf@wlug.westbo.se>
+ * Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* ipt_SET.c - netfilter target to manipulate IP sets */
+
+#include <linux/module.h>
+#include <linux/skbuff.h>
+
+#include <linux/netfilter_ipv4/ip_tables.h>
+#include <linux/netfilter_ipv4/ipt_set.h>
+
+static unsigned int
+target(struct sk_buff **pskb,
+       const struct net_device *in,
+       const struct net_device *out,
+       unsigned int hooknum,
+       const void *targinfo,
+       void *userinfo)
+{
+	const struct ipt_set_info_target *info = targinfo;
+	
+	if (info->add_set.index != NF_SET_INVALID_ID)
+		nf_set_add_kernel(info->add_set.index,
+				    *pskb,
+				    info->add_set.flags);
+	if (info->del_set.index != NF_SET_INVALID_ID)
+		nf_set_del_kernel(info->del_set.index,
+				    *pskb,
+				    info->del_set.flags);
+
+	return IPT_CONTINUE;
+}
+
+static int
+checkentry(const char *tablename,
+	   const struct ipt_entry *e,
+	   void *targinfo,
+	   unsigned int targinfosize, unsigned int hook_mask)
+{
+	struct ipt_set_info_target *info = 
+		(struct ipt_set_info_target *) targinfo;
+
+	if (targinfosize != IPT_ALIGN(sizeof(*info))) {
+		DP("bad target info size %u", targinfosize);
+		return 0;
+	}
+
+	if (info->add_set.name[0] != '\0') {
+		info->add_set.index = nf_set_get_byname(info->add_set.name);
+		if (info->add_set.index == NF_SET_INVALID_ID) {
+			nf_set_printk("cannot find set %s as target",
+				      info->add_set.name);
+			return 0;	/* error */
+		}
+	} else
+		info->add_set.index = NF_SET_INVALID_ID;
+
+	if (info->del_set.name[0] != '\0') {
+		info->del_set.index = nf_set_get_byname(info->del_set.name);
+		if (info->del_set.index == NF_SET_INVALID_ID) {
+			nf_set_printk("cannot find set %s as target",
+				      info->del_set.name);
+			return 0;	/* error */
+		}
+	} else
+		info->del_set.index = NF_SET_INVALID_ID;
+	
+	if (info->add_set.flags[NF_SET_MAX_STORAGE] != 0
+	    || info->del_set.flags[NF_SET_MAX_STORAGE] != 0) {
+		nf_set_printk("That's nasty!");
+		return 0;	/* error */
+	}
+
+	return 1;
+}
+
+static void destroy(void *targetinfo, unsigned int targetsize)
+{
+	struct ipt_set_info_target *info = targetinfo;
+
+	if (targetsize != IPT_ALIGN(sizeof(struct ipt_set_info_target))) {
+		nf_set_printk("invalid targetsize %d", targetsize);
+		return;
+	}
+
+	if (info->add_set.index != NF_SET_INVALID_ID)
+		nf_set_put_byindex(info->add_set.index);
+	if (info->del_set.index != NF_SET_INVALID_ID)
+		nf_set_put_byindex(info->del_set.index);
+}
+
+static struct ipt_target SET_target = {
+	.name 		= "SET",
+	.target 	= target,
+	.checkentry 	= checkentry,
+	.destroy 	= destroy,
+	.me 		= THIS_MODULE
+};
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("iptables IP set target module");
+
+static int __init init(void)
+{
+	return ipt_register_target(&SET_target);
+}
+
+static void __exit fini(void)
+{
+	ipt_unregister_target(&SET_target);
+}
+
+module_init(init);
+module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/ipv4/netfilter/ipt_set.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ipt_set.c
--- linux-2.6.15.3-orig/net/ipv4/netfilter/ipt_set.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ipt_set.c	2006-03-13 13:20:50.000000000 +0100
@@ -0,0 +1,109 @@
+/* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
+ *                         Patrick Schaaf <bof@bof.de>
+ *                         Martin Josefsson <gandalf@wlug.westbo.se>
+ * Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* Kernel module to match an IP set. */
+
+#include <linux/module.h>
+#include <linux/skbuff.h>
+
+#include <linux/netfilter_ipv4/ip_tables.h>
+#include <linux/netfilter_ipv4/ipt_set.h>
+
+static inline int
+match_set(const struct ipt_set_info *info,
+	  const struct sk_buff *skb,
+	  int inv)
+{	
+	if (nf_set_test_kernel(info->index, skb, info->flags))
+		inv = !inv;
+	return inv;
+}
+
+static int
+match(const struct sk_buff *skb,
+      const struct net_device *in,
+      const struct net_device *out,
+      const void *matchinfo,
+      int offset,
+      int *hotdrop)
+{
+	const struct ipt_set_info_match *info = matchinfo;
+		
+	return match_set(&info->match_set,
+			 skb,
+			 info->match_set.flags[0] & NFSET_MATCH_INV);
+}
+
+static int
+checkentry(const char *tablename,
+	   const struct ipt_ip *ip,
+	   void *matchinfo,
+	   unsigned int matchsize,
+	   unsigned int hook_mask)
+{
+	struct ipt_set_info_match *info = 
+		(struct ipt_set_info_match *) matchinfo;
+
+	if (matchsize != IPT_ALIGN(sizeof(struct ipt_set_info_match))) {
+		nf_set_printk("invalid matchsize %d", matchsize);
+		return 0;
+	}
+
+	info->match_set.index = nf_set_get_byname(info->match_set.name);
+		
+	if (info->match_set.index == NF_SET_INVALID_ID) {
+		nf_set_printk("Cannot find set %s to match",
+			      info->match_set.name);
+		return 0;	/* error */
+	}
+	if (info->match_set.flags[NF_SET_MAX_STORAGE] != 0) {
+		nf_set_printk("That's nasty!");
+		return 0;	/* error */
+	}
+
+	return 1;
+}
+
+static void destroy(void *matchinfo, unsigned int matchsize)
+{
+	struct ipt_set_info_match *info = matchinfo;
+
+	if (matchsize != IPT_ALIGN(sizeof(struct ipt_set_info_match))) {
+		nf_set_printk("invalid matchsize %d", matchsize);
+		return;
+	}
+
+	nf_set_put_byindex(info->match_set.index);
+}
+
+static struct ipt_match set_match = {
+	.name		= "set",
+	.match		= &match,
+	.checkentry	= &checkentry,
+	.destroy	= &destroy,
+	.me		= THIS_MODULE
+};
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("iptables IP set match module");
+
+static int __init init(void)
+{
+	return ipt_register_match(&set_match);
+}
+
+static void __exit fini(void)
+{
+	ipt_unregister_match(&set_match);
+}
+
+module_init(init);
+module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/Kconfig linux-2.6.15.3-nfset/net/netfilter/Kconfig
--- linux-2.6.15.3-orig/net/netfilter/Kconfig	2006-02-07 00:36:47.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/Kconfig	2006-03-09 10:23:51.000000000 +0100
@@ -95,4 +95,82 @@
 
 	  To compile it as a module, choose M here.  If unsure, say N.
 
+config NF_SET
+	tristate "IP set support"
+	depends on INET && NETFILTER
+	help
+	  This option adds IP set support to the kernel.
+	  In order to define and use sets, you need the userspace utility
+	  nfset(8).
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
+config NF_SET_MAX
+	int "Maximum number of IP sets"
+	default 256
+	range 2 65534
+	depends on NF_SET
+	help
+	  You can define here default value of the maximum number 
+	  of IP sets for the kernel.
+
+	  The value can be overriden by the 'max_sets' module
+	  parameter of the 'nf_set' module.
+
+config NF_SET_IPMAP
+	tristate "ipmap set support"
+	depends on NF_SET
+	help
+	  This option adds the ipmap set type support.
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
+config NF_SET_MACIPMAP
+	tristate "macipmap set support"
+	depends on NF_SET
+	help
+	  This option adds the macipmap set type support.
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
+config NF_SET_PORTMAP
+	tristate "portmap set support"
+	depends on NF_SET
+	help
+	  This option adds the portmap set type support.
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
+config NF_SET_IPHASH
+	tristate "iphash set support"
+	depends on NF_SET
+	help
+	  This option adds the iphash set type support.
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
+config NF_SET_NETHASH
+	tristate "nethash set support"
+	depends on NF_SET
+	help
+	  This option adds the nethash set type support.
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
+config NF_SET_IPPORTHASH
+	tristate "ipporthash set support"
+	depends on NF_SET
+	help
+	  This option adds the ipporthash set type support.
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
+config NF_SET_IPTREE
+	tristate "iptree set support"
+	depends on NF_SET
+	help
+	  This option adds the iptree set type support.
+
+	  To compile it as a module, choose M here.  If unsure, say N.
+
 endmenu
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/Makefile linux-2.6.15.3-nfset/net/netfilter/Makefile
--- linux-2.6.15.3-orig/net/netfilter/Makefile	2006-02-07 00:36:47.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/Makefile	2006-03-08 15:48:59.000000000 +0100
@@ -2,6 +2,16 @@
 
 obj-$(CONFIG_NETFILTER) = netfilter.o
 
+# sets
+obj-$(CONFIG_NF_SET) += nf_set.o
+obj-$(CONFIG_NF_SET_IPMAP) += nf_set_ipmap.o
+obj-$(CONFIG_NF_SET_PORTMAP) += nf_set_portmap.o
+obj-$(CONFIG_NF_SET_MACIPMAP) += nf_set_macipmap.o
+obj-$(CONFIG_NF_SET_IPHASH) += nf_set_iphash.o
+obj-$(CONFIG_NF_SET_NETHASH) += nf_set_nethash.o
+obj-$(CONFIG_NF_SET_IPPORTHASH) += nf_set_ipporthash.o
+obj-$(CONFIG_NF_SET_IPTREE) += nf_set_iptree.o
+
 obj-$(CONFIG_NETFILTER_NETLINK) += nfnetlink.o
 obj-$(CONFIG_NETFILTER_NETLINK_QUEUE) += nfnetlink_queue.o
 obj-$(CONFIG_NETFILTER_NETLINK_LOG) += nfnetlink_log.o
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/nf_set.c linux-2.6.15.3-nfset/net/netfilter/nf_set.c
--- linux-2.6.15.3-orig/net/netfilter/nf_set.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/nf_set.c	2006-03-13 19:17:05.000000000 +0100
@@ -0,0 +1,1407 @@
+/* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
+ *                         Patrick Schaaf <bof@bof.de>
+ *			   Martin Josefsson <gandalf@wlug.westbo.se>
+ * Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* Kernel module for IP set management */
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/kmod.h>
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/ip.h>
+#include <linux/skbuff.h>
+#include <linux/random.h>
+#include <linux/jhash.h>
+#include <linux/errno.h>
+#include <asm/uaccess.h>
+#include <asm/bitops.h>
+#include <asm/semaphore.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+
+#define ASSERT_READ_LOCK(x)	/* dont use that */
+#define ASSERT_WRITE_LOCK(x)
+#include <linux/netfilter_ipv4/listhelp.h>
+#include <linux/netfilter/nfnetlink.h>
+#include <linux/netfilter/nfnetlink_set.h>
+#include <linux/netfilter/nf_set.h>
+
+static struct list_head set_type_list;		/* all registered sets */
+static struct nf_set **nf_set_list;		/* all individual sets */
+static DEFINE_RWLOCK(nf_set_lock);		/* protects the lists */
+static nf_set_id_t nf_set_max = CONFIG_NF_SET_MAX; /* max number of sets */
+static unsigned int nf_set_hash_random;		/* random seed */
+
+#define NFSET_BUFFER_LEN (NLMSG_GOODSIZE - NFA_LENGTH(0) - NFA_ALIGNTO - 1)	
+
+/* Oh my, netlink_dump_start makes life hard :-( */
+static DEFINE_RWLOCK(nfset_list_lock);		/* Protect the global variables */ 
+static nf_set_id_t nfset_list_id = NF_SET_INVALID_ID;	/* The set we are dumping */
+static nf_set_id_t *nfset_list_ids = NULL;		/* Snapshot of ids */
+static unsigned char list_buffer[NFSET_BUFFER_LEN];
+
+static char __initdata version[] = "0.20";
+
+/* Shamelessly stolen from rtnetlink.h */
+#define BUG_TRAP(x) do { \
+	if (unlikely(!(x))) { \
+		printk(KERN_ERR "KERNEL: assertion (%s) failed at %s (%d)\n", \
+			#x,  __FILE__ , __LINE__); \
+	} \
+} while(0)
+
+/*
+ * Unified cache management
+ */
+struct nf_set_cache {
+	char name[16];
+	size_t size;
+	unsigned int use;
+	kmem_cache_t *cache;
+};
+
+/* Prevent creating the caches with the same name */
+DECLARE_MUTEX(nf_set_cache_mutex);
+static struct nf_set_cache *nf_set_cache[8] = {};
+
+int nf_set_cache_create(size_t size, unsigned int *id)
+{
+	struct nf_set_cache *cache;
+	int i, j, ret = 0;
+	
+	down(&nf_set_cache_mutex);
+	for (i = 0, j = 8; i < 8; i++) {
+		if (nf_set_cache[i] == NULL && j == 8)
+			j = i;
+		else if (nf_set_cache[i] && nf_set_cache[i]->size == size) {
+			*id = i;
+			nf_set_cache[i]->use++;
+			goto up_mutex;
+		}
+	}
+	*id = j;	
+	BUG_TRAP(j == 8);
+	
+	cache = kmalloc(sizeof(struct nf_set_cache), GFP_KERNEL);
+	if (!cache) {
+		ret = -ENOMEM;
+		goto up_mutex;
+	}
+	
+	cache->size = size;
+	sprintf(cache->name, "nf_set_cache%u", size);
+	cache->use = 1;
+	cache->cache = kmem_cache_create(cache->name, size, 0, 0, NULL, NULL);
+	if (cache->cache)
+		goto up_mutex;
+	
+	ret = -ENOMEM;
+	kfree(cache);
+    up_mutex:
+    	up(&nf_set_cache_mutex);
+    	
+    	return ret;
+}
+		
+void nf_set_cache_destroy(unsigned int id)
+{
+	BUG_TRAP(!nf_set_cache[id]);
+
+	down(&nf_set_cache_mutex);
+	if (--nf_set_cache[id]->use > 0) {
+		up(&nf_set_cache_mutex);
+		return;
+	}
+	kmem_cache_destroy(nf_set_cache[id]->cache);
+	kfree(nf_set_cache[id]);
+	nf_set_cache[id] = NULL;
+    	up(&nf_set_cache_mutex);
+}
+
+void * nf_set_cache_alloc(unsigned int id, gfp_t flags)
+{
+	BUG_TRAP(!nf_set_cache[id]);
+	return kmem_cache_alloc(nf_set_cache[id]->cache, flags);
+}
+
+void nf_set_cache_free(unsigned int id, void *data)
+{
+	BUG_TRAP(!nf_set_cache[id]);
+	kmem_cache_free(nf_set_cache[id]->cache, data);
+}
+		
+/*
+ * Sets can be identified by name, index or id.
+ * From kernel (i.e netfilter set/SET match and target
+ * modules) we refer to the sets by the index.
+ * From userspace we refer to the sets by name and id.
+ */
+
+static inline void
+__nf_set_get(nf_set_id_t index)
+{
+	atomic_inc(&nf_set_list[index]->ref);
+}
+
+static inline void
+__nf_set_put(nf_set_id_t index)
+{
+	atomic_dec(&nf_set_list[index]->ref);
+}
+
+/*
+ * Kernel space routines
+ */
+
+/* Add, del and test set entries from kernel */
+
+int
+nf_set_test_kernel(nf_set_id_t index,
+		   const struct sk_buff *skb,
+		   const u_int32_t *flags)
+{
+	struct nf_set *set;
+	int res;
+
+	BUG_TRAP(index >= nf_set_max || !flags[0]);
+	
+	read_lock_bh(&nf_set_lock);
+	set = nf_set_list[index];
+	read_unlock_bh(&nf_set_lock);
+	NF_SET_ASSERT(set);
+	DP("set %s, index %u", set->name, index);
+	
+	read_lock_bh(&set->lock);
+	res = set->subtype->test_kernel(set, skb, flags);
+	read_unlock_bh(&set->lock);
+
+	return res;
+}
+
+void
+nf_set_add_kernel(nf_set_id_t index,
+		  const struct sk_buff *skb,
+		  const u_int32_t *flags)
+{
+	struct nf_set *set;
+
+	BUG_TRAP(index >= nf_set_max || !flags[0]);
+
+	read_lock_bh(&nf_set_lock);
+	set = nf_set_list[index];
+	read_unlock_bh(&nf_set_lock);
+	NF_SET_ASSERT(set);
+	DP("set %s, index %u", set->name, index);
+
+	write_lock_bh(&set->lock);
+	set->subtype->add_kernel(set, skb, flags);
+	write_unlock_bh(&set->lock);
+}
+
+void
+nf_set_del_kernel(nf_set_id_t index,
+		  const struct sk_buff *skb,
+		  const u_int32_t *flags)
+{
+	struct nf_set *set;
+
+	BUG_TRAP(index >= nf_set_max || !flags[0]);
+
+	read_lock_bh(&nf_set_lock);
+	set = nf_set_list[index];
+	read_unlock_bh(&nf_set_lock);
+	NF_SET_ASSERT(set);
+	DP("set %s, index %u", set->name, index);
+	
+	write_lock_bh(&set->lock);
+	set->subtype->del_kernel(set, skb, flags);
+	write_unlock_bh(&set->lock);
+}
+
+/* Get set (index) and put by index */
+
+nf_set_id_t
+nf_set_get_byname(const char *name)
+{
+	nf_set_id_t i, index = NF_SET_INVALID_ID;
+	
+	read_lock_bh(&nf_set_lock);
+	for (i = 0; i < nf_set_max; i++) {
+		if (nf_set_list[i] != NULL
+		    && strcmp(nf_set_list[i]->name, name) == 0) {
+			__nf_set_get(i);
+			index = i;
+			break;
+		}
+	}
+	read_unlock_bh(&nf_set_lock);
+	return index;
+}
+
+void nf_set_put_byindex(nf_set_id_t index)
+{
+	read_lock_bh(&nf_set_lock);
+	if (index < nf_set_max && nf_set_list[index])
+		__nf_set_put(index);
+	read_unlock_bh(&nf_set_lock);
+}
+
+/* Register and deregister settype */
+
+static inline int
+set_type_equal(const struct nf_set_type *set_type, const char *str2)
+{
+	return !strncmp(set_type->typename, str2, NF_SET_MAXNAMELEN - 1);
+}
+
+static inline struct nf_set_type *
+find_set_type(const char *name)
+{
+	return LIST_FIND(&set_type_list,
+			 set_type_equal,
+			 struct nf_set_type *,
+			 name);
+}
+
+int 
+nf_set_register_set_type(struct nf_set_type *set_type)
+{
+	int ret = 0;
+	
+	if (set_type->protocol_version != NF_SET_PROTOCOL_VERSION) {
+		nf_set_printk("'%s' uses wrong protocol version %u (want %u)",
+			      set_type->typename,
+			      set_type->protocol_version,
+			      NF_SET_PROTOCOL_VERSION);
+		return -EINVAL;
+	}
+
+	write_lock_bh(&nf_set_lock);
+	if (find_set_type(set_type->typename)) {
+		/* Duplicate! */
+		nf_set_printk("'%s' already registered!", 
+			      set_type->typename);
+		ret = -EINVAL;
+		goto unlock;
+	}
+	if (!try_module_get(THIS_MODULE)) {
+		ret = -EFAULT;
+		goto unlock;
+	}
+	list_append(&set_type_list, set_type);
+	DP("'%s' registered.", set_type->typename);
+   unlock:
+	write_unlock_bh(&nf_set_lock);
+	return ret;
+}
+
+void
+nf_set_unregister_set_type(struct nf_set_type *set_type)
+{
+	write_lock_bh(&nf_set_lock);
+	if (!find_set_type(set_type->typename)) {
+		nf_set_printk("'%s' not registered?",
+			      set_type->typename);
+		goto unlock;
+	}
+	LIST_DELETE(&set_type_list, set_type);
+	module_put(THIS_MODULE);
+	DP("'%s' unregistered.", set_type->typename);
+   unlock:
+	write_unlock_bh(&nf_set_lock);
+
+}
+
+/*
+ * Userspace routines
+ */
+
+/*
+ * Find set by name, reference it once. The reference makes sure the
+ * thing pointed to, does not go away under our feet. Drop the reference
+ * later, using nfset_put().
+ */
+static struct nf_set *
+nfset_get(const char *name)
+{
+	nf_set_id_t i;
+	struct nf_set *set = NULL;
+	
+	read_lock_bh(&nf_set_lock);
+	for (i = 0; i < nf_set_max; i++) {
+		if (nf_set_list[i] != NULL
+		    && strcmp(nf_set_list[i]->name, name) == 0) {
+			__nf_set_get(i);
+			set = nf_set_list[i];
+			break;
+		}
+	}
+	read_unlock_bh(&nf_set_lock);
+	return set;
+}
+
+static struct nf_set *
+nfset_get_byid(nf_set_id_t id)
+{
+	nf_set_id_t i;
+	struct nf_set *set = NULL;
+	
+	read_lock_bh(&nf_set_lock);
+	for (i = 0; i < nf_set_max; i++) {
+		if (nf_set_list[i] != NULL
+		    && nf_set_list[i]->id == id) {
+			__nf_set_get(i);
+			set = nf_set_list[i];
+			break;
+		}
+	}
+	read_unlock_bh(&nf_set_lock);
+	return set;
+}
+
+/*
+ * If the given set pointer points to a valid set, decrement
+ * reference count by 1. The caller shall not assume the id
+ * to be valid, after calling this function.
+ */
+static void 
+nfset_put(nf_set_id_t id)
+{
+	nf_set_id_t i;
+	
+	read_lock_bh(&nf_set_lock);
+	for (i = 0; i < nf_set_max; i++) {
+		if (nf_set_list[i] != NULL
+		    && nf_set_list[i]->id == id) {
+			__nf_set_put(i);
+			break;
+		}
+	}
+	read_unlock_bh(&nf_set_lock);
+}
+
+/*
+ * Create a set
+ */
+static struct nf_set_type *
+find_set_type_rlock(const char *typename)
+{
+	struct nf_set_type *type;
+	
+	read_lock_bh(&nf_set_lock);
+	type = find_set_type(typename);
+	if (type == NULL)
+		read_unlock_bh(&nf_set_lock);
+
+	/* read_unlock_bh(&nf_set_lock) is called in nf_set_create! */
+	return type;
+}
+
+static int
+find_free_id(const char *name,
+	     nf_set_id_t *index,
+	     nf_set_id_t *id)
+{
+	nf_set_id_t i;
+
+	*id = NF_SET_INVALID_ID;
+	for (i = 0;  i < nf_set_max; i++) {
+		if (nf_set_list[i] == NULL) {
+			if (*id == NF_SET_INVALID_ID)
+				*id = *index = i;
+		} else if (strcmp(name, nf_set_list[i]->name) == 0)
+			/* Name clash */
+			return -EEXIST;
+	}
+	if (*id == NF_SET_INVALID_ID)
+		/* No free slot remained */
+		return -ERANGE;
+	/* Check that index is usable as id (swapping) */
+    check:	
+	for (i = 0;  i < nf_set_max; i++) {
+		if (nf_set_list[i] != NULL
+		    && nf_set_list[i]->id == *id) {
+		    *id = i;
+		    goto check;
+		}
+	}
+	return 0;
+}
+
+/* Convert attributes to the unified set header data */
+static inline int 
+attr_to_proto_general(struct nfattr *tb[], struct nfset_proto *proto)
+{
+	if (tb[NFSET_ATTR_GENERAL_SIZE-1]) {
+		proto->gen.size = 
+			*(__u32 *)NFA_DATA(tb[NFSET_ATTR_GENERAL_SIZE-1]);
+		proto->flags &= NFSET_FLAG_GEN_SIZE;
+	}
+	if (tb[NFSET_ATTR_GENERAL_LIMIT-1]) {
+		proto->gen.limit = 
+			*(__u32 *)NFA_DATA(tb[NFSET_ATTR_GENERAL_LIMIT-1]);
+		proto->flags &= NFSET_FLAG_GEN_LIMIT;
+	}
+	if (tb[NFSET_ATTR_GENERAL_TIMEOUT-1]) {
+		proto->gen.timeout = 
+			*(__u32 *)NFA_DATA(tb[NFSET_ATTR_GENERAL_TIMEOUT-1]);
+		proto->flags &= NFSET_FLAG_GEN_TIMEOUT;
+	}
+	if (tb[NFSET_ATTR_GENERAL_FLAGS-1]) {
+		proto->gen.flags = 
+			*(__u32 *)NFA_DATA(tb[NFSET_ATTR_GENERAL_FLAGS-1]);
+		proto->flags &= NFSET_FLAG_GEN_FLAGS;
+	}
+	return 0;
+}
+
+static inline int 
+attr_to_proto_l2(struct nfattr *tb[], struct nfset_proto *proto)
+{
+	if (tb[NFSET_ATTR_L2_ETHERNET-1]) {
+		strncpy(proto->l2.ethernet,
+			NFA_DATA(tb[NFSET_ATTR_L2_ETHERNET-1]),
+			ETH_ALEN);
+		proto->flags &= NFSET_FLAG_L2_ETHER;
+	}
+	return 0;
+}
+
+static inline int 
+attr_to_proto_l3(struct nfattr *tb[], struct nfset_proto *proto)
+{
+	if (tb[NFSET_ATTR_L3_PROTONUM-1]) {
+		proto->l3.protonum = 
+			*(__u16 *)NFA_DATA(tb[NFSET_ATTR_L3_PROTONUM-1]);
+		proto->flags &= NFSET_FLAG_L3_PROTONUM;
+	} else
+		return -1;
+
+	switch (proto->l3.protonum) {
+	case AF_INET:
+		if (tb[NFSET_ATTR_L3_IPV4_FROM-1]) {
+			proto->l3.from.ipv4 =
+				*(__u32 *)NFA_DATA(tb[NFSET_ATTR_L3_IPV4_FROM-1]);
+			proto->flags &= NFSET_FLAG_L3_FROM;
+		}
+		if (tb[NFSET_ATTR_L3_IPV4_TO-1]) {
+			proto->l3.to.ipv4 =
+				*(__u32 *)NFA_DATA(tb[NFSET_ATTR_L3_IPV4_TO-1]);
+			proto->flags &= NFSET_FLAG_L3_TO;
+		}
+		break;
+	case AF_INET6:
+		if (tb[NFSET_ATTR_L3_IPV6_FROM-1]) {
+			memcpy(proto->l3.from.ipv6,
+			       (__u32 *)NFA_DATA(tb[NFSET_ATTR_L3_IPV6_FROM-1]),
+			       sizeof(proto->l3.from.ipv6));
+			proto->flags &= NFSET_FLAG_L3_FROM;
+		}
+		if (tb[NFSET_ATTR_L3_IPV6_TO-1]) {
+			memcpy(proto->l3.to.ipv6,
+			       (__u32 *)NFA_DATA(tb[NFSET_ATTR_L3_IPV6_TO-1]),
+			       sizeof(proto->l3.to.ipv6));
+			proto->flags &= NFSET_FLAG_L3_TO;
+		}
+		break;
+	}
+	if (tb[NFSET_ATTR_L3_MASK-1]) {
+		proto->l3.mask = 
+			*(__u32 *)NFA_DATA(tb[NFSET_ATTR_L3_MASK-1]);
+		proto->flags &= NFSET_FLAG_L3_MASK;
+	}
+	return 0;
+}
+
+static inline int 
+attr_to_proto_l4(struct nfattr *tb[], struct nfset_proto *proto)
+{
+	if (tb[NFSET_ATTR_L4_FROM-1]) {
+		proto->l4.from = 
+			*(__u16 *)NFA_DATA(tb[NFSET_ATTR_L4_FROM-1]);
+		proto->flags &= NFSET_FLAG_L4_FROM;
+	}
+	if (tb[NFSET_ATTR_L4_TO-1]) {
+		proto->l4.to = 
+			*(__u16 *)NFA_DATA(tb[NFSET_ATTR_L4_TO-1]);
+		proto->flags &= NFSET_FLAG_L4_TO;
+	}
+	return 0;
+}
+
+static int attr_to_proto(struct nfattr *tb[], struct nfset_proto *proto)
+{	
+	if (tb[NFSET_ATTR_HEADER_GENERAL-1]) {
+		struct nfattr *tb2[NFSET_ATTR_GENERAL_MAX];
+		
+		nfattr_parse_nested(tb2, NFSET_ATTR_GENERAL_MAX, 
+				    tb[NFSET_ATTR_HEADER_GENERAL-1]);
+
+		if (attr_to_proto_general(tb2, proto))
+			return -1;
+	}
+	if (tb[NFSET_ATTR_HEADER_L2DATA-1]) {
+		struct nfattr *tb2[NFSET_ATTR_L2_MAX];
+		
+		nfattr_parse_nested(tb2, NFSET_ATTR_L2_MAX, 
+				    tb[NFSET_ATTR_HEADER_L2DATA-1]);
+
+		if (attr_to_proto_l2(tb2, proto))
+			return -1;
+	}
+	if (tb[NFSET_ATTR_HEADER_L3DATA-1]) {
+		struct nfattr *tb2[NFSET_ATTR_L3_MAX];
+		
+		nfattr_parse_nested(tb2, NFSET_ATTR_L3_MAX, 
+				    tb[NFSET_ATTR_HEADER_L3DATA-1]);
+		
+		if (attr_to_proto_l3(tb2, proto))
+			return -1;
+	}
+	if (tb[NFSET_ATTR_HEADER_L4DATA-1]) {
+		struct nfattr *tb2[NFSET_ATTR_L4_MAX];
+		
+		nfattr_parse_nested(tb2, NFSET_ATTR_L4_MAX, 
+				    tb[NFSET_ATTR_HEADER_L4DATA-1]);
+		
+		if (attr_to_proto_l4(tb2, proto))
+			return -1;
+	}
+	return 0;
+}
+
+static int
+nfset_create(struct sock *ctnl, struct sk_buff *skb,
+	     struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	char *name, *typename;
+	unsigned int subtype;
+	struct nf_set *set;
+	nf_set_id_t index, id;
+	int res = 0;
+	struct nfattr *tb2[NFSET_ATTR_HEADER_MAX];
+	struct nfset_proto proto = {};
+
+	if (!tb[NFSET_CREATE_NAME-1])
+		return -EINVAL;
+	name = NFA_DATA(tb[NFSET_CREATE_NAME-1]);
+	name[NF_SET_MAXNAMELEN-1] = '\0';
+
+	if (!tb[NFSET_CREATE_TYPENAME-1])
+		return -EINVAL;
+	typename = NFA_DATA(tb[NFSET_CREATE_TYPENAME-1]);
+	typename[NF_SET_MAXNAMELEN-1] = '\0';
+
+	if (!tb[NFSET_CREATE_SUBTYPE-1])
+		return -EINVAL;
+	subtype = *(unsigned int *)NFA_DATA(tb[NFSET_CREATE_SUBTYPE-1]);
+
+	/*
+	 * The data part comes in netlink format. 
+	 */
+	if (!tb[NFSET_CREATE_DATA-1])
+		return -EINVAL;
+	nfattr_parse_nested(tb2, NFSET_ATTR_HEADER_MAX, 
+			    tb[NFSET_CREATE_DATA-1]);
+	if (attr_to_proto(tb2, &proto))
+		return -EINVAL;
+
+	/*
+	 * First, and without any locks, allocate and initialize
+	 * a normal base set structure.
+	 */
+	DP("setname: %s, typename: %s subtype: %u", name, typename, subtype);
+	set = kmalloc(sizeof(struct nf_set), GFP_KERNEL);
+	if (!set)
+		return -ENOMEM;
+	set->lock = RW_LOCK_UNLOCKED;
+	strncpy(set->name, name, NF_SET_MAXNAMELEN);
+	atomic_set(&set->ref, 0);
+
+	/*
+	 * Next, take the &nf_set_lock, check that we know the type,
+	 * and take a reference on the type, to make sure it
+	 * stays available while constructing our new set.
+	 *
+	 * After referencing the type, we drop the &nf_set_lock,
+	 * and let the new set construction run without locks.
+	 */
+	set->type = find_set_type_rlock(typename);
+	if (set->type == NULL) {
+		/* Try loading the module */
+		char modulename[NF_SET_MAXNAMELEN + strlen("nf_set_") + 1];
+		strcpy(modulename, "nf_set_");
+		strcat(modulename, typename);
+		DP("try to load %s", modulename);
+		request_module(modulename);
+		set->type = find_set_type_rlock(typename);
+	}
+	if (set->type == NULL) {
+		nf_set_printk("no set type '%s', set '%s' not created",
+			      typename, name);
+		res = -ENOENT;
+		goto out;
+	}
+	if (!try_module_get(set->type->me)) {
+		read_unlock_bh(&nf_set_lock);
+		res = -EFAULT;
+		goto out;
+	}
+	read_unlock_bh(&nf_set_lock);
+
+	/* 
+	 * Check subtype 
+	 */
+	if (subtype < set->type->subtype_base
+	    || subtype >= set->type->subtype_next) {
+	    	res = -ENOTSUPP;
+	    	goto put_out;
+	}
+	set->subtype = &set->type->subtypes[subtype];
+
+	/*
+	 * Without holding any locks, create private part.
+	 */
+	res = set->subtype->create(set, &proto);
+	if (res != 0)
+		goto put_out;
+
+	/* BTW, res==0 here. */
+
+	/*
+	 * Here, we have a valid, constructed set. &nf_set_lock again,
+	 * check that it is not already in nf_set_list.
+	 */
+	write_lock_bh(&nf_set_lock);
+	if ((res = find_free_id(set->name, &index, &id)) != 0) {
+		DP("no free index!");
+		goto cleanup;
+	}
+
+	/*
+	 * Finally! Add our shiny new set to the list, and be done.
+	 */
+	DP("create: '%s' created with index %u, id %u!", set->name, index, id);
+	set->id = id;
+	nf_set_list[index] = set;
+	write_unlock_bh(&nf_set_lock);
+	return res;
+	
+    cleanup:
+	write_unlock_bh(&nf_set_lock);
+	set->subtype->destroy(set);
+    put_out:
+	module_put(set->type->me);
+    out:
+	kfree(set);
+	return res;
+}
+
+/*
+ * Destroy a set - or all sets
+ * Sets must not be referenced/used.
+ */
+static inline void 
+__destroy(struct nf_set *set)
+{
+	set->subtype->destroy(set);
+	module_put(set->type->me);
+	kfree(set);
+}
+
+static int
+nfset_destroy(struct sock *ctnl, struct sk_buff *skb,
+	      struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	nf_set_id_t i;
+	char *name;
+	int ret = 0;
+
+	if (!tb[NFSET_LIST_NAME-1])
+		return EINVAL;
+	name = NFA_DATA(tb[NFSET_LIST_NAME-1]);
+	name[NF_SET_MAXNAMELEN-1] = '\0';
+	DP("setname: %s", name);
+
+	write_lock_bh(&nf_set_lock);
+	for (i = 0; i < nf_set_max; i++) {
+		if (nf_set_list[i] != NULL
+		    && (name[0] == '\0'
+		        || strcmp(name, nf_set_list[i]->name) == 0)
+		    && atomic_read(&nf_set_list[i]->ref)) {
+		    	ret = -EBUSY;
+		    	goto unlock;
+		}
+	}
+	for (i = 0; i < nf_set_max; i++) {
+		if (nf_set_list[i] != NULL
+		    && (name[0] == '\0'
+		        || strcmp(name, nf_set_list[i]->name) == 0)) {
+		        /* No reference exists and neither can spring into
+		         * existence: no need to use the set lock */
+			DP("set: %s",  nf_set_list[i]->name);
+			__destroy(nf_set_list[i]);
+			nf_set_list[i] = NULL;
+		}
+	}
+unlock:
+	write_unlock_bh(&nf_set_lock);
+
+	return ret;
+}
+
+/* 
+ * Flush data in a set - or in all sets
+ */
+static int
+nfset_flush(struct sock *ctnl, struct sk_buff *skb,
+	    struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	struct nf_set *set;
+	nf_set_id_t i;
+	char *name;
+
+	if (!tb[NFSET_LIST_NAME-1])
+		return EINVAL;
+	name = NFA_DATA(tb[NFSET_LIST_NAME-1]);
+	name[NF_SET_MAXNAMELEN-1] = '\0';
+
+	read_lock_bh(&nf_set_lock);
+	for (i = 0; i < nf_set_max; i++)
+		if (nf_set_list[i] != NULL
+		    && (name[0] == '\0'
+		        || strcmp(name, nf_set_list[i]->name) == 0)) {
+			set = nf_set_list[i];
+			DP("set: %s",  set->name);
+
+			write_lock_bh(&set->lock);
+			set->subtype->flush(set);
+			write_unlock_bh(&set->lock);
+		}
+	read_unlock_bh(&nf_set_lock);
+
+	return 0;
+}
+
+/* Rename a set */
+static int
+nfset_rename(struct sock *ctnl, struct sk_buff *skb,
+	     struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	struct nf_set *set = NULL;
+	nf_set_id_t i;
+	int ret = 0;
+	char *from, *to;
+
+	if (!tb[NFSET_RENAME_FROM-1])
+		return -EINVAL;
+	from = NFA_DATA(tb[NFSET_RENAME_FROM-1]);
+	from[NF_SET_MAXNAMELEN-1] = '\0';
+
+	if (!tb[NFSET_RENAME_TO-1])
+		return -EINVAL;
+	to = NFA_DATA(tb[NFSET_RENAME_TO-1]);
+	to[NF_SET_MAXNAMELEN-1] = '\0';
+	DP("set: from %s to %s",  from, to);
+
+	write_lock_bh(&nf_set_lock);
+	for (i = 0; i < nf_set_max; i++) {
+		if (nf_set_list[i] != NULL) {
+			if (strcmp(nf_set_list[i]->name, from) == 0) {
+				set = nf_set_list[i];
+			} else if (strcmp(nf_set_list[i]->name, to) == 0) {
+				ret = -EEXIST;
+				goto unlock;
+			}
+		}
+	}
+	if (set != NULL)
+		strncpy(set->name, to, NF_SET_MAXNAMELEN);
+	else
+		ret = -ENOENT;
+    unlock:
+	write_unlock_bh(&nf_set_lock);
+	return ret;
+}
+
+/*
+ * Swap two sets so that name/index points to the other.
+ */
+static int
+nfset_swap(struct sock *ctnl, struct sk_buff *skb,
+	   struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	struct nf_set *from_set, *to_set;
+	u_int32_t from_ref;
+	nf_set_id_t i, from_id, to_id;
+	char *from, *to;
+	int ret = 0;
+
+	if (!tb[NFSET_RENAME_FROM-1])
+		return -EINVAL;
+	from = NFA_DATA(tb[NFSET_RENAME_FROM-1]);
+	from[NF_SET_MAXNAMELEN-1] = '\0';
+
+	if (!tb[NFSET_RENAME_TO-1])
+		return -EINVAL;
+	to = NFA_DATA(tb[NFSET_RENAME_TO-1]);
+	to[NF_SET_MAXNAMELEN-1] = '\0';
+
+	from_id = to_id = NF_SET_INVALID_ID;
+	DP("set: from %s to %s",  from, to);
+	write_lock_bh(&nf_set_lock);
+	for (i = 0; i < nf_set_max; i++) {
+		if (nf_set_list[i] != NULL) {
+			if (strcmp(nf_set_list[i]->name, from) == 0) {
+				from_id = i;
+			} else if (strcmp(nf_set_list[i]->name, to) == 0) {
+				to_id = i;
+			}
+		}
+	}
+	if (from_id == NF_SET_INVALID_ID || to_id == NF_SET_INVALID_ID) {
+		ret = -EEXIST;
+		goto unlock;
+	}
+	from_set = nf_set_list[from_id];
+	to_set = nf_set_list[to_id];
+	from_ref = atomic_read(&from_set->ref);
+
+	strncpy(from_set->name, to, NF_SET_MAXNAMELEN);
+	atomic_set(&from_set->ref, atomic_read(&to_set->ref));
+	strncpy(to_set->name, from, NF_SET_MAXNAMELEN);
+	atomic_set(&to_set->ref, from_ref);
+	
+	nf_set_list[from_id] = to_set;
+	nf_set_list[to_id] = from_set;
+	
+    unlock:
+	write_unlock_bh(&nf_set_lock);
+	return ret;
+}
+
+static inline struct nlmsghdr *__nfset_nfnetlink_header(struct sk_buff *skb)
+{
+	int type = 0;
+	struct nlmsghdr *nlh;
+	struct nfgenmsg *nfmsg;
+
+	type |= NFNL_SUBSYS_SET << 8;
+	nlh   = NLMSG_PUT(skb, 0, 0, type, sizeof(struct nfgenmsg));
+	nfmsg = NLMSG_DATA(nlh);
+
+	nlh->nlmsg_flags    = 0;
+	nfmsg->nfgen_family = AF_INET;
+	nfmsg->version	    = NFNETLINK_V0;
+	nfmsg->res_id	    = 0;
+
+	return nlh;
+
+nlmsg_failure:
+	return NULL;
+}
+
+#define __ADT_TEST	0
+#define __ADT_ADD	1
+#define __ADT_DEL	2
+
+static inline int
+nfset_adt(struct sock *ctnl, struct sk_buff *skb,
+	  struct nlmsghdr *nlh, struct nfattr *tb[], int *errp, int mode)
+{
+	nf_set_id_t id;
+	unsigned int flags = 0;
+	struct nf_set *set;
+	int res = 0;
+	
+	if (!tb[NFSET_ADT_ID-1])
+		return -EINVAL;
+	id = *(nf_set_id_t *)NFA_DATA(tb[NFSET_ADT_ID-1]);
+	
+	/* Unused at testing */
+	if (tb[NFSET_ADT_FLAGS-1])
+		flags = *(unsigned int *)NFA_DATA(tb[NFSET_ADT_FLAGS-1]);
+	
+	if (!tb[NFSET_ADT_DATA-1])
+		return -EINVAL;
+	
+	set = nfset_get_byid(id);
+	if (set == NULL)
+		return -ENOENT;
+	
+	switch (mode) {
+	case __ADT_ADD:
+		write_lock_bh(&set->lock);
+		res = set->subtype->add(set,
+				  NFA_DATA(tb[NFSET_ADT_DATA-1]),
+		 		  tb[NFSET_ADT_DATA-1]->nfa_len,
+		 		  flags);
+		write_unlock_bh(&set->lock);
+		break;
+	case __ADT_DEL:
+		write_lock_bh(&set->lock);
+		res = set->subtype->del(set,
+				  NFA_DATA(tb[NFSET_ADT_DATA-1]),
+		 		  tb[NFSET_ADT_DATA-1]->nfa_len,
+		 		  flags);
+		write_unlock_bh(&set->lock);
+		break;
+	case __ADT_TEST:
+		read_lock_bh(&set->lock);
+		res = set->subtype->test(set,
+				  NFA_DATA(tb[NFSET_ADT_DATA-1]),
+		 		  tb[NFSET_ADT_DATA-1]->nfa_len,
+		 		  flags);
+		read_unlock_bh(&set->lock);
+		break;
+	}
+
+	nfset_put(set->id);
+	return res;
+}
+
+static int
+nfset_add(struct sock *ctnl, struct sk_buff *skb,
+	  struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	return nfset_adt(ctnl, skb, nlh, tb, errp, __ADT_ADD);
+}
+
+static int
+nfset_del(struct sock *ctnl, struct sk_buff *skb,
+	  struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	return nfset_adt(ctnl, skb, nlh, tb, errp, __ADT_DEL);
+}
+
+static int
+nfset_test(struct sock *ctnl, struct sk_buff *skb,
+	   struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	return nfset_adt(ctnl, skb, nlh, tb, errp, __ADT_TEST);
+}
+
+static int
+nfset_adt_get(struct sock *ctnl, struct sk_buff *skb,
+	      struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	char *name;
+	struct sk_buff *skb2;
+	struct nlmsghdr *nlh2;
+	unsigned char *b;
+	struct nf_set *set;
+	int ret = 0;
+
+	if (!tb[NFSET_LIST_NAME-1])
+		return -EINVAL;
+	name = NFA_DATA(tb[NFSET_LIST_NAME-1]);
+	name[NF_SET_MAXNAMELEN-1] = '\0';
+
+	set = nfset_get(name); 
+	if (set == NULL)
+		return -ENOENT;
+
+	skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
+	if (!skb2) {
+		ret = -ENOMEM;
+		goto alloc_failure;
+	}
+	b = skb2->tail;
+
+	nlh2 = __nfset_nfnetlink_header(skb2);
+	if (!nlh2) {
+		ret = -ENOSPC;
+		goto nfattr_failure;
+	}
+	
+	NFA_PUT(skb2, NFSET_GET_ID, 
+		sizeof(nf_set_id_t),
+		&set->id);
+	NFA_PUT(skb2, NFSET_GET_TYPENAME, 
+		strlen(set->type->typename),
+		set->type->typename);
+	NFA_PUT(skb2, NFSET_GET_SUBTYPE_BASE,
+		sizeof(unsigned int),
+		&set->type->subtype_base);
+	NFA_PUT(skb2, NFSET_GET_SUBTYPE_NEXT,
+		sizeof(unsigned int),
+		&set->type->subtype_next);
+
+	nlh2->nlmsg_len = skb2->tail - b;
+
+	nfset_put(set->id);
+
+	return netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
+
+nfattr_failure:
+	kfree_skb(skb2);
+alloc_failure:
+	nfset_put(set->id);
+	return ret;
+}
+
+static int
+nfset_stats(struct sock *ctnl, struct sk_buff *skb,
+	    struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	return 0;
+}
+
+static int proto_to_attr(struct sk_buff *skb, struct nfset_proto *proto)
+{
+	struct nfattr *nest_parms;
+	
+	if (proto->flags & NFSET_FLAG_GEN) {
+		nest_parms = NFA_NEST(skb,  NFSET_ATTR_HEADER_GENERAL);
+		if (proto->flags & NFSET_FLAG_GEN_SIZE)
+			NFA_PUT(skb, NFSET_ATTR_GENERAL_SIZE, 
+				sizeof(proto->gen.size), 
+				&proto->gen.size);
+		if (proto->flags & NFSET_FLAG_GEN_LIMIT)
+			NFA_PUT(skb, NFSET_ATTR_GENERAL_LIMIT, 
+				sizeof(proto->gen.limit), 
+				&proto->gen.limit);
+		if (proto->flags & NFSET_FLAG_GEN_TIMEOUT)
+			NFA_PUT(skb, NFSET_ATTR_GENERAL_TIMEOUT, 
+				sizeof(proto->gen.timeout), 
+				&proto->gen.timeout);
+		if (proto->flags & NFSET_FLAG_GEN_FLAGS)
+			NFA_PUT(skb, NFSET_ATTR_GENERAL_FLAGS, 
+				sizeof(proto->gen.flags), 
+				&proto->gen.flags);
+		NFA_NEST_END(skb, nest_parms);
+	}
+	if (proto->flags & NFSET_FLAG_L2) {
+		nest_parms = NFA_NEST(skb,  NFSET_ATTR_HEADER_L2DATA);
+		if (proto->flags & NFSET_FLAG_L2_ETHER)
+			NFA_PUT(skb, NFSET_ATTR_L2_ETHERNET, 
+				sizeof(proto->l2.ethernet), 
+				&proto->l2.ethernet);
+		NFA_NEST_END(skb, nest_parms);
+	}
+	if (proto->flags & NFSET_FLAG_L3) {
+		nest_parms = NFA_NEST(skb,  NFSET_ATTR_HEADER_L3DATA);
+		NFA_PUT(skb, NFSET_ATTR_L3_PROTONUM, 
+			sizeof(proto->l3.protonum), 
+			&proto->l3.protonum);
+		if (proto->l3.protonum == AF_INET) {
+			if (proto->flags & NFSET_FLAG_L3_FROM)
+				NFA_PUT(skb, NFSET_ATTR_L3_IPV4_FROM, 
+					sizeof(proto->l3.from.ipv4),
+					&proto->l3.from.ipv4);
+			if (proto->flags & NFSET_FLAG_L3_TO)
+				NFA_PUT(skb, NFSET_ATTR_L3_IPV4_TO, 
+					sizeof(proto->l3.to.ipv4),
+					&proto->l3.to.ipv4);
+		} else {
+			if (proto->flags & NFSET_FLAG_L3_FROM)
+				NFA_PUT(skb, NFSET_ATTR_L3_IPV6_FROM, 
+					sizeof(proto->l3.from.ipv6),
+					&proto->l3.from.ipv6);
+			if (proto->flags & NFSET_FLAG_L3_TO)
+				NFA_PUT(skb, NFSET_ATTR_L3_IPV6_TO, 
+					sizeof(proto->l3.to.ipv6),
+					&proto->l3.to.ipv6);
+		}
+		if (proto->flags & NFSET_FLAG_L3_MASK)
+			NFA_PUT(skb, NFSET_ATTR_L3_MASK, 
+				sizeof(proto->l3.mask),
+				&proto->l3.mask);
+		NFA_NEST_END(skb, nest_parms);
+	}
+	if (proto->flags & NFSET_FLAG_L4) {
+		nest_parms = NFA_NEST(skb,  NFSET_ATTR_HEADER_L4DATA);
+		if (proto->flags & NFSET_FLAG_L4_FROM)
+			NFA_PUT(skb, NFSET_ATTR_L4_FROM, 
+				sizeof(proto->l4.from), 
+				&proto->l4.from);
+		if (proto->flags & NFSET_FLAG_L4_TO)
+			NFA_PUT(skb, NFSET_ATTR_L4_TO, 
+				sizeof(proto->l4.to), 
+				&proto->l4.to);
+		NFA_NEST_END(skb, nest_parms);
+	}
+	return 0;
+
+nfattr_failure:
+
+	return -1;
+}
+
+static int list_done(struct netlink_callback *cb)
+{
+	DP("entered %s\n", __FUNCTION__);
+	
+	write_lock_bh(&nfset_list_lock);
+	kfree(nfset_list_ids);
+	nfset_list_ids = NULL;
+	nfset_list_id = NF_SET_INVALID_ID;
+	write_unlock_bh(&nfset_list_lock);
+	return 0;
+}
+
+static int
+list_dump(struct sk_buff *skb, struct netlink_callback *cb)
+{
+	struct nlmsghdr *nlh;
+	unsigned char *b;
+	int len;
+	nf_set_id_t i;
+	struct nf_set *set = NULL;
+
+	b = skb->tail;
+	nlh = __nfset_nfnetlink_header(skb);
+
+	for (i = nfset_list_id; i < nf_set_max && !set; i++) {
+		if (nfset_list_ids[i] != NF_SET_INVALID_ID)
+			/* We siletly ignore deleted sets */
+			set = nfset_get_byid(nfset_list_ids[i]);
+	}
+	if (!set)
+		return -1;
+
+	nfset_list_id = i;
+	if (!cb->args[0]) {
+		struct nfset_proto proto = {};	
+
+		set->subtype->list_header(set, &proto);
+		proto_to_attr(skb, &proto);
+		cb->args[0] = 1;
+		goto header_listed;
+	}
+	read_lock_bh(&set->lock);
+	len = set->subtype->list_members(set, list_buffer, NFSET_BUFFER_LEN, 
+					 cb->args);
+	read_unlock_bh(&set->lock);
+	NFA_PUT(skb, NFSET_LIST_DATA, len, list_buffer);
+
+header_listed:
+	nlh->nlmsg_len = skb->tail - b;
+	nfset_put(set->id);
+
+	return skb->len;
+
+nfattr_failure:
+	nfset_put(set->id);
+	return -1;
+}
+
+static int
+nfset_list(struct sock *ctnl, struct sk_buff *skb,
+	   struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	int ret = 0;
+	nf_set_id_t i;
+	
+	write_lock_bh(&nfset_list_lock);
+	if (nfset_list_id != NF_SET_INVALID_ID) {
+		ret = -EBUSY;
+		goto failure;
+	}
+	nfset_list_ids = kmalloc(nf_set_max * sizeof(nf_set_id_t), GFP_ATOMIC);
+	if (!nfset_list_ids) {
+		ret = -ENOMEM;
+		goto failure;
+	}
+	write_unlock_bh(&nfset_list_lock);
+	read_lock_bh(&nf_set_lock);
+	for (i = 0; i < nf_set_max; i++)
+		nfset_list_ids[i] = nf_set_list[i] ? nf_set_list[i]->id
+						   : NF_SET_INVALID_ID;
+	nfset_list_id = 0;	/* index in nfset_list_ids! */
+	read_unlock_bh(&nf_set_lock);
+	
+	return netlink_dump_start(ctnl, skb, nlh,
+				  list_dump,
+				  list_done);
+
+failure:
+	write_unlock_bh(&nfset_list_lock);
+	return ret;
+}
+
+static int list_set_done(struct netlink_callback *cb)
+{
+	DP("entered %s\n", __FUNCTION__);
+
+	write_lock_bh(&nfset_list_lock);
+	nfset_list_id = NF_SET_INVALID_ID;
+	write_unlock_bh(&nfset_list_lock);
+	return 0;
+}
+
+static int
+list_set_dump(struct sk_buff *skb, struct netlink_callback *cb)
+{
+	struct nlmsghdr *nlh;
+	unsigned char *b;
+	int len;
+	struct nf_set *set;
+	
+	set = nfset_get_byid(nfset_list_id);
+	if (!set)
+		return -1;
+
+	b = skb->tail;
+	nlh = __nfset_nfnetlink_header(skb);	
+	if (!cb->args[0]) {
+		struct nfset_proto proto = {};	
+
+		set->subtype->list_header(set, &proto);
+		proto_to_attr(skb, &proto);
+		cb->args[0] = 1;
+		goto header_listed;
+	}
+
+	read_lock_bh(&set->lock);
+	len = set->subtype->list_members(set, list_buffer, NFSET_BUFFER_LEN,
+					 cb->args);
+	read_unlock_bh(&set->lock);
+	NFA_PUT(skb, NFSET_LIST_DATA, len, list_buffer);
+
+header_listed:
+	nlh->nlmsg_len = skb->tail - b;
+	nfset_put(set->id);
+
+	return skb->len;
+
+nfattr_failure:
+	nfset_put(set->id);
+	return -1;
+}
+
+static int
+nfset_list_set(struct sock *ctnl, struct sk_buff *skb,
+	       struct nlmsghdr *nlh, struct nfattr *tb[], int *errp)
+{
+	char *name;
+	struct nf_set *set;
+	int ret = 0;
+
+	if (!tb[NFSET_LIST_NAME-1])
+		return -EINVAL;
+	name = NFA_DATA(tb[NFSET_LIST_NAME-1]);
+	name[NF_SET_MAXNAMELEN-1] = '\0';
+
+	set = nfset_get(name); 
+	if (set == NULL)
+		return -ENOENT;
+	nfset_list_id = set->id;
+	nfset_put(set->id);
+
+	write_lock_bh(&nfset_list_lock);
+	if (nfset_list_id == NF_SET_INVALID_ID)
+		nfset_list_id = set->id;
+	else {
+		ret = -EBUSY;
+		goto failure;
+	}
+	write_unlock_bh(&nfset_list_lock);
+
+	return netlink_dump_start(ctnl, skb, nlh,
+				  list_set_dump,
+				  list_set_done);
+
+failure:
+	write_unlock_bh(&nfset_list_lock);
+	return ret;
+}
+
+static struct nfnl_callback nfset_cb[NLSET_MSG_MAX] = {
+	[NLSET_OP_CREATE]	= { .call = nfset_create,
+				    .attr_count = NFSET_CREATE_MAX },
+	[NLSET_OP_DESTROY] 	= { .call = nfset_destroy,
+				    .attr_count = NFSET_LIST_MAX },
+	[NLSET_OP_FLUSH]  	= { .call = nfset_flush,
+				    .attr_count = NFSET_LIST_MAX },
+	[NLSET_OP_RENAME] 	= { .call = nfset_rename,
+				    .attr_count = NFSET_RENAME_MAX },
+	[NLSET_OP_SWAP] 	= { .call = nfset_swap,
+				    .attr_count = NFSET_RENAME_MAX },
+	[NLSET_OP_ADT_GET] 	= { .call = nfset_adt_get,
+				    .attr_count = NFSET_LIST_MAX },
+	[NLSET_OP_ADD] 		= { .call = nfset_add,
+				    .attr_count = NFSET_ADT_MAX },
+	[NLSET_OP_DEL] 		= { .call = nfset_del,
+				    .attr_count = NFSET_ADT_MAX },
+	[NLSET_OP_TEST] 	= { .call = nfset_test,
+				    .attr_count = NFSET_ADT_MAX },
+	[NLSET_OP_LIST_SET] 	= { .call = nfset_list_set,
+				    .attr_count = NFSET_LIST_MAX },
+	[NLSET_OP_LIST] 	= { .call = nfset_list,
+				    .attr_count = 0 },
+	[NLSET_OP_STATS]	= { .call = nfset_stats,
+				    .attr_count = 0 },
+};
+
+static struct nfnetlink_subsystem nfset_subsys = {
+	.name				= "nf_set",
+	.subsys_id			= NFNL_SUBSYS_SET,
+	.cb_count			= NLSET_MSG_MAX,
+	.cb				= nfset_cb
+};
+
+MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_SET);
+
+static int max_sets;
+module_param(max_sets, int, 0600);
+MODULE_PARM_DESC(max_sets, "maximal number of sets");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("module implementing core set support");
+
+static int __init init(void)
+{
+	int ret = 0;
+
+	get_random_bytes(&nf_set_hash_random, 4);
+	if (max_sets)
+		nf_set_max = max_sets;
+	nf_set_list = vmalloc(sizeof(struct nf_set *) * nf_set_max);
+	if (!nf_set_list) {
+		printk(KERN_ERR "Unable to create nf_set_list\n");
+		return -ENOMEM;
+	}
+	memset(nf_set_list, 0, sizeof(struct nf_set *) * nf_set_max);
+
+	INIT_LIST_HEAD(&set_type_list);
+
+	ret = nfnetlink_subsys_register(&nfset_subsys);
+	if (ret < 0) {
+		printk("init: cannot register with nfnetlink.\n");
+		vfree(nf_set_list);
+	}
+	printk("nf_set v.%s\n", version); 
+	return ret;
+}
+
+static void __exit fini(void)
+{
+	/* There can't be any existing set */
+	nfnetlink_subsys_unregister(&nfset_subsys);
+	vfree(nf_set_list);
+	DP("these are the famous last words");
+}
+
+EXPORT_SYMBOL(nf_set_register_set_type);
+EXPORT_SYMBOL(nf_set_unregister_set_type);
+
+EXPORT_SYMBOL(nf_set_get_byname);
+EXPORT_SYMBOL(nf_set_put_byindex);
+
+EXPORT_SYMBOL(nf_set_add_kernel);
+EXPORT_SYMBOL(nf_set_del_kernel);
+EXPORT_SYMBOL(nf_set_test_kernel);
+
+module_init(init);
+module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/nf_set_iphash.c linux-2.6.15.3-nfset/net/netfilter/nf_set_iphash.c
--- linux-2.6.15.3-orig/net/netfilter/nf_set_iphash.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/nf_set_iphash.c	2006-03-13 19:36:34.000000000 +0100
@@ -0,0 +1,264 @@
+/* Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* Kernel module implementing an ip hash set */
+
+#include <linux/module.h>
+#include <linux/ip.h>
+#include <linux/skbuff.h>
+#include <linux/errno.h>
+#include <linux/random.h>
+#include <linux/vmalloc.h>
+#include <net/ip.h>
+
+#include <linux/netfilter/nf_set_malloc.h>
+#include <linux/netfilter/nf_set_jhash.h>
+#include <linux/netfilter/nf_set_iphash_common.h>
+#include <linux/netfilter/nf_set_iphash.h>
+
+static unsigned int cache_id;
+
+static inline int
+__testip(struct nf_set *set, nf_set_ip_t ip)
+{
+	struct nf_set_iphash *map = (struct nf_set_iphash *) set->data;
+	nf_set_ip_t haship = ip & map->netmask;
+
+	DP("set: %s, ip:%u.%u.%u.%u, mask:%u.%u.%u.%u %u.%u.%u.%u",
+	   set->name, HIPQUAD(ip), HIPQUAD(map->netmask), HIPQUAD(haship));
+	return __iphash_testip(&map->map, haship);
+}
+
+static int
+testip(struct nf_set *set, const void *data, size_t size, unsigned int flags)
+{	
+	nf_set_ip_t *ip = (nf_set_ip_t *) data;
+
+	return __testip(set, ip[0]);
+}
+
+static int
+testip_kernel(struct nf_set *set, 
+	      const struct sk_buff *skb,
+	      const u_int32_t *flags)
+{
+	return __testip(set,
+			ntohl(flags[0] & NFSET_SRC 
+				? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+}
+
+static inline int
+__addip(struct nf_set *set, nf_set_ip_t ip)
+{
+	struct nf_set_iphash *map = (struct nf_set_iphash *) set->data;
+	nf_set_ip_t haship = ip & map->netmask;
+
+	DP("set: %s, ip:%u.%u.%u.%u, mask:%u.%u.%u.%u %u.%u.%u.%u",
+	   set->name, HIPQUAD(ip), HIPQUAD(map->netmask), HIPQUAD(haship));
+	return __iphash_addip(cache_id, &map->map, haship);	
+}
+
+static int
+addip(struct nf_set *set, const void *data, size_t size, unsigned int flags)
+{
+	nf_set_ip_t *ip = (nf_set_ip_t *) data;
+	unsigned int i, len;
+	int ret = 0;
+	
+	for (i = 0, len = 0; len < size; i++, len += sizeof(nf_set_ip_t)) {
+		ret = __addip(set, ip[i]);
+		if (ret && !(flags & NFSET_IGNORE_ERRORS))
+			return ret;
+	}
+	return ret;
+}
+
+static int
+addip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	return __addip(set,
+		       ntohl(flags[0] & NFSET_SRC 
+		       		? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+}
+
+static inline int
+__delip(struct nf_set *set, nf_set_ip_t ip)
+{
+	struct nf_set_iphash *map = (struct nf_set_iphash *) set->data;
+	nf_set_ip_t haship = ip & map->netmask;
+
+	DP("set: %s, ip:%u.%u.%u.%u, mask:%u.%u.%u.%u %u.%u.%u.%u",
+	   set->name, HIPQUAD(ip), HIPQUAD(map->netmask), HIPQUAD(haship));
+	return __iphash_delip(cache_id, &map->map, haship);	
+}
+
+static int
+delip(struct nf_set *set, const void *data, size_t size, unsigned int flags)
+{
+	nf_set_ip_t *ip = (nf_set_ip_t *) data;
+	unsigned int i;
+	int ret = 0;
+	
+	for (i = 0; i < size; i += sizeof(nf_set_ip_t)) {
+		ret = __delip(set, ip[i]);
+		if (ret && !(flags & NFSET_IGNORE_ERRORS))
+			return ret;
+	}
+	return ret;
+}
+
+static int
+delip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	return __delip(set,
+		       ntohl(flags[0] & NFSET_SRC 
+				? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+}
+
+static int create(struct nf_set *set, const struct nfset_proto *data)
+{
+	struct nf_set_iphash *map;
+
+	if (!(data->flags & set->subtype->flags))
+		return -EINVAL;
+
+	if (data->gen.size < 1) {
+		nf_set_printk("hashsize too small");
+		return -ENOEXEC;
+	}
+	if (data->gen.limit < 1) {
+		nf_set_printk("limit too small");
+		return -ENOEXEC;
+	}
+
+	map = kmalloc(sizeof(struct nf_set_iphash)
+		      + data->gen.size * sizeof(struct iphash *), GFP_KERNEL);
+	if (!map) {
+		DP("out of memory for %d bytes", 
+		    sizeof(struct nf_set_iphash)
+		    + data->gen.size * sizeof(struct iphash *));
+		return -ENOMEM;
+	}
+	memset(map, 0,
+	       sizeof(struct nf_set_iphash)
+	       + data->gen.size * sizeof(struct iphash *));
+	map->netmask = data->l3.mask;
+
+	map->map.hashsize = data->gen.size;
+	map->map.limit = data->gen.limit;
+	get_random_bytes(&map->map.initval, 4);
+
+	set->data = map;
+	return 0;
+}
+
+static void destroy(struct nf_set *set)
+{
+	struct nf_set_iphash *map = (struct nf_set_iphash *) set->data;
+
+	__iphash_destroy(cache_id, &map->map);
+	kfree(map);
+	set->data = NULL;
+}
+
+static void flush(struct nf_set *set)
+{
+	struct nf_set_iphash *map = (struct nf_set_iphash *) set->data;
+
+	__iphash_flush(cache_id, &map->map);
+}
+
+static void list_header(const struct nf_set *set, struct nfset_proto *data)
+{
+	struct nf_set_iphash *map = (struct nf_set_iphash *) set->data;
+
+	data->flags = set->subtype->flags;
+	data->gen.size = map->map.hashsize;
+	data->gen.limit = map->map.limit;
+	data->l3.mask = map->netmask;
+}
+
+static int list_members(const struct nf_set *set, void *buffer, int len,
+			long args[5])
+{
+	struct nf_set_iphash *map = (struct nf_set_iphash *) set->data;
+	nf_set_id_t *ip = (nf_set_id_t *) buffer;
+	int size;
+	__u32 i;
+	
+	for (size = 0, i = 0; 
+	     args[1] < map->map.hashsize && size < len; 
+	     args[1]++, i++) {
+		/* TODO */
+		ip[args[1]] = 0;	
+	}
+	
+	return size;
+}
+
+static struct nf_set_type nf_set_iphash = {
+	.typename		= SETTYPE_NAME,
+	.features		= NFSET_TYPE_IP | NFSET_TYPE_SINGLE,
+	.subtype_base		= 0,
+	.subtype_next		= 1,
+	.me			= THIS_MODULE,
+	.subtypes		= {
+		[0] = {
+			.create		= &create,
+			.flags		= (NFSET_FLAG_GEN_SIZE
+					   | NFSET_FLAG_GEN_LIMIT
+					   | NFSET_FLAG_L3_MASK),
+			.destroy	= &destroy,
+			.flush		= &flush,
+			.add		= &addip,
+			.add_kernel	= &addip_kernel,
+			.del		= &delip,
+			.del_kernel	= &delip_kernel,
+			.test		= &testip,
+			.test_kernel	= &testip_kernel,
+			.list_header	= &list_header,
+			.list_members	= &list_members,
+		},
+	},
+};
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("iphash type of IP sets");
+
+static int __init init(void)
+{
+	int ret;
+	
+	ret = nf_set_cache_create(sizeof(struct iphash), &cache_id);
+	if (ret) {
+		printk(KERN_ERR "Unable to create slab cache for nf_set_iphash\n");
+		return ret;
+	}
+	ret = nf_set_register_set_type(&nf_set_iphash);
+	if (ret)
+		nf_set_cache_destroy(cache_id);
+
+	return ret;
+}
+
+static void __exit fini(void)
+{	
+	/* FIXME: possible race with nf_set_create() */
+	nf_set_unregister_set_type(&nf_set_iphash);
+	nf_set_cache_destroy(cache_id);
+}
+
+module_init(init);
+module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/nf_set_ipmap.c linux-2.6.15.3-nfset/net/netfilter/nf_set_ipmap.c
--- linux-2.6.15.3-orig/net/netfilter/nf_set_ipmap.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/nf_set_ipmap.c	2006-03-13 14:50:31.000000000 +0100
@@ -0,0 +1,314 @@
+/* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
+ *                         Patrick Schaaf <bof@bof.de>
+ * Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* Kernel module implementing an IP set type: the single bitmap type */
+
+#include <linux/module.h>
+#include <linux/ip.h>
+#include <linux/skbuff.h>
+#include <linux/errno.h>
+#include <asm/uaccess.h>
+#include <asm/bitops.h>
+
+#include <linux/netfilter/nfnetlink.h>
+#include <linux/netfilter/nf_set_ipmap.h>
+
+static inline nf_set_ip_t
+ip_to_id(const struct nf_set_ipmap *map, nf_set_ip_t ip)
+{
+	return (ip - map->first_ip)/map->hosts;
+}
+
+static inline int
+__testip(struct nf_set *set, nf_set_ip_t ip)
+{
+	struct nf_set_ipmap *map = (struct nf_set_ipmap *) set->data;
+	
+	if (ip < map->first_ip || ip > map->last_ip)
+		return -ERANGE;
+
+	DP("set: %s, ip:%u.%u.%u.%u, mask:%u.%u.%u.%u %u.%u.%u.%u",
+	   set->name, HIPQUAD(ip), HIPQUAD(map->netmask), HIPQUAD(ip & map->netmask));
+	return !!test_bit(ip_to_id(map, ip & map->netmask), map->members);
+}
+
+static int
+testip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_ipmap *req = 
+	    (struct nf_set_req_ipmap *) data;
+
+	if (size != sizeof(struct nf_set_req_ipmap)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_ipmap),
+			      size);
+		return -EINVAL;
+	}
+	return __testip(set, req->ip);
+}
+
+static int
+testip_kernel(struct nf_set *set, 
+	      const struct sk_buff *skb,
+	      const u_int32_t *flags)
+{
+	int res;
+	
+	DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u",
+	   flags[index] & NFSET_SRC ? "SRC" : "DST",
+	   NIPQUAD(skb->nh.iph->saddr),
+	   NIPQUAD(skb->nh.iph->daddr));
+
+	res =  __testip(set,
+			ntohl(flags[index] & NFSET_SRC 
+				? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+	return (res < 0 ? 0 : res);
+}
+
+static inline int
+__addip(struct nf_set *set, nf_set_ip_t ip)
+{
+	struct nf_set_ipmap *map = (struct nf_set_ipmap *) set->data;
+
+	if (ip < map->first_ip || ip > map->last_ip)
+		return -ERANGE;
+
+	DP("set: %s, ip:%u.%u.%u.%u, mask:%u.%u.%u.%u %u.%u.%u.%u",
+	   set->name, HIPQUAD(ip), HIPQUAD(map->netmask), HIPQUAD(ip & map->netmask));
+	if (test_and_set_bit(ip_to_id(map, ip & map->netmask), map->members))
+		return -EEXIST;
+
+	return 0;
+}
+
+static int
+addip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_ipmap *req = 
+	    (struct nf_set_req_ipmap *) data;
+
+	if (size != sizeof(struct nf_set_req_ipmap)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_ipmap),
+			      size);
+		return -EINVAL;
+	}
+	DP("%u.%u.%u.%u", HIPQUAD(req->ip));
+	return __addip(set, req->ip);
+}
+
+static int
+addip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	return __addip(set,
+		       ntohl(flags[index] & NFSET_SRC 
+		       		? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+}
+
+static inline int 
+__delip(struct nf_set *set, nf_set_ip_t ip)
+{
+	struct nf_set_ipmap *map = (struct nf_set_ipmap *) set->data;
+
+	if (ip < map->first_ip || ip > map->last_ip)
+		return -ERANGE;
+
+	DP("set: %s, ip:%u.%u.%u.%u, mask:%u.%u.%u.%u %u.%u.%u.%u",
+	   set->name, HIPQUAD(ip), HIPQUAD(map->netmask), HIPQUAD(ip & map->netmask));
+	if (!test_and_clear_bit(ip_to_id(map, ip & map->netmask), map->members))
+		return -EEXIST;
+	
+	return 0;
+}
+
+static int
+delip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_ipmap *req =
+	    (struct nf_set_req_ipmap *) data;
+
+	if (size != sizeof(struct nf_set_req_ipmap)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_ipmap),
+			      size);
+		return -EINVAL;
+	}
+	return __delip(set, req->ip);
+}
+
+static int
+delip_kernel(struct nf_set *set,
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	return __delip(set,
+		       ntohl(flags[index] & NFSET_SRC 
+				? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+}
+
+static int create(struct nf_set *set, const void *data, size_t size)
+{
+	int newbytes;
+	struct nf_set_req_ipmap_create *req =
+	    (struct nf_set_req_ipmap_create *) data;
+	struct nf_set_ipmap *map;
+
+	if (size != sizeof(struct nf_set_req_ipmap_create)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_ipmap_create),
+			      size);
+		return -EINVAL;
+	}
+
+	DP("from %u.%u.%u.%u to %u.%u.%u.%u",
+	   HIPQUAD(req->from), HIPQUAD(req->to));
+
+	if (req->from > req->to) {
+		DP("bad ip range");
+		return -ENOEXEC;
+	}
+
+	map = kmalloc(sizeof(struct nf_set_ipmap), GFP_KERNEL);
+	if (!map) {
+		DP("out of memory for %d bytes",
+		   sizeof(struct nf_set_ipmap));
+		return -ENOMEM;
+	}
+	map->first_ip = req->from;
+	map->last_ip = req->to;
+	map->netmask = req->netmask;
+
+	if (req->netmask == 0xFFFFFFFF) {
+		map->hosts = 1;
+		map->sizeid = map->last_ip - map->first_ip + 1;
+	} else {
+		unsigned int mask_bits, netmask_bits;
+		nf_set_ip_t mask;
+		
+		map->first_ip &= map->netmask;	/* Should we better bark? */
+		
+		mask = range_to_mask(map->first_ip, map->last_ip, &mask_bits);
+		netmask_bits = mask_to_bits(map->netmask);
+		
+		if ((!mask && (map->first_ip || map->last_ip != 0xFFFFFFFF))
+		    || netmask_bits <= mask_bits)
+			return -ENOEXEC;
+
+		DP("mask_bits %u, netmask_bits %u",
+		   mask_bits, netmask_bits);
+		map->hosts = 2 << (32 - netmask_bits - 1);
+		map->sizeid = 2 << (netmask_bits - mask_bits - 1);
+	}
+	if (map->sizeid > MAX_RANGE + 1) {
+		nf_set_printk("range too big (max %d addresses)",
+			       MAX_RANGE+1);
+		kfree(map);
+		return -ENOEXEC;
+	}
+	DP("hosts %u, sizeid %u", map->hosts, map->sizeid);
+	newbytes = bitmap_bytes(0, map->sizeid - 1);
+	map->members = kmalloc(newbytes, GFP_KERNEL);
+	if (!map->members) {
+		DP("out of memory for %d bytes", newbytes);
+		kfree(map);
+		return -ENOMEM;
+	}
+	memset(map->members, 0, newbytes);
+	
+	set->data = map;
+	return 0;
+}
+
+static void destroy(struct nf_set *set)
+{
+	struct nf_set_ipmap *map = (struct nf_set_ipmap *) set->data;
+	
+	kfree(map->members);
+	kfree(map);
+	
+	set->data = NULL;
+}
+
+static void flush(struct nf_set *set)
+{
+	struct nf_set_ipmap *map = (struct nf_set_ipmap *) set->data;
+	memset(map->members, 0, bitmap_bytes(0, map->sizeid - 1));
+}
+
+static void list_header(const struct nf_set *set, void *data)
+{
+	struct nf_set_ipmap *map = (struct nf_set_ipmap *) set->data;
+	struct nf_set_req_ipmap_create *header =
+	    (struct nf_set_req_ipmap_create *) data;
+
+	header->from = map->first_ip;
+	header->to = map->last_ip;
+	header->netmask = map->netmask;
+}
+
+static int list_members_size(const struct nf_set *set)
+{
+	struct nf_set_ipmap *map = (struct nf_set_ipmap *) set->data;
+
+	return bitmap_bytes(0, map->sizeid - 1);
+}
+
+static void list_members(const struct nf_set *set, void *data)
+{
+	struct nf_set_ipmap *map = (struct nf_set_ipmap *) set->data;
+	int bytes = bitmap_bytes(0, map->sizeid - 1);
+
+	memcpy(data, map->members, bytes);
+}
+
+static struct nf_set_type nf_set_ipmap = {
+	.typename		= SETTYPE_NAME,
+	.features		= IPSET_TYPE_IP | IPSET_TYPE_SINGLE,
+	.subtype_base		= 0,
+	.subtype_next		= 1,
+	.me			= THIS_MODULE,
+	.subtypes		= {
+		[0] = {
+			.create		= &create,
+			.destroy	= &destroy,
+			.flush		= &flush,
+			.reqsize	= sizeof(struct nf_set_req_ipmap),
+			.addip		= &addip,
+			.addip_kernel	= &addip_kernel,
+			.delip		= &delip,
+			.delip_kernel	= &delip_kernel,
+			.testip		= &testip,
+			.testip_kernel	= &testip_kernel,
+			.list		= &list,
+		},
+	},
+};
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("ipmap type of IP sets");
+
+static int __init init(void)
+{
+	return nf_set_register_set_type(&nf_set_ipmap);
+}
+
+static void __exit fini(void)
+{
+	/* FIXME: possible race with nf_set_create() */
+	nf_set_unregister_set_type(&nf_set_ipmap);
+}
+
+module_init(init);
+module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/nf_set_ipporthash.c linux-2.6.15.3-nfset/net/netfilter/nf_set_ipporthash.c
--- linux-2.6.15.3-orig/net/netfilter/nf_set_ipporthash.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/nf_set_ipporthash.c	2006-03-08 23:39:18.000000000 +0100
@@ -0,0 +1,388 @@
+/* Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* Kernel module implementing an ip+port hash set */
+
+#include <linux/module.h>
+#include <linux/ip.h>
+#include <linux/tcp.h>
+#include <linux/udp.h>
+#include <linux/skbuff.h>
+#include <linux/errno.h>
+#include <linux/random.h>
+
+#include <net/ip.h>
+
+#include <linux/netfilter/nf_set_malloc.h>
+#include <linux/netfilter/nf_set_jhash.h>
+#include <linux/netfilter/nf_set_iphash_common.h>
+#include <linux/netfilter/nf_set_ipporthash.h>
+
+static unsigned int cache_id;
+
+/* We must handle non-linear skbs */
+static inline nf_set_ip_t
+get_port(const struct sk_buff *skb, u_int32_t flags)
+{
+	struct iphdr *iph = skb->nh.iph;
+	u_int16_t offset = ntohs(iph->frag_off) & IP_OFFSET;
+
+	switch (iph->protocol) {
+	case IPPROTO_TCP: {
+		struct tcphdr tcph;
+		
+		/* See comments at tcp_match in ip_tables.c */
+		if (offset)
+			return INVALID_PORT;
+
+		if (skb_copy_bits(skb, skb->nh.iph->ihl*4, &tcph, sizeof(tcph)) < 0)
+			/* No choice either */
+			return INVALID_PORT;
+	     	
+	     	return ntohs(flags & NFSET_SRC ?
+			     tcph.source : tcph.dest);
+	    }
+	case IPPROTO_UDP: {
+		struct udphdr udph;
+
+		if (offset)
+			return INVALID_PORT;
+
+		if (skb_copy_bits(skb, skb->nh.iph->ihl*4, &udph, sizeof(udph)) < 0)
+			/* No choice either */
+			return INVALID_PORT;
+	     	
+	     	return ntohs(flags & NFSET_SRC ?
+			     udph.source : udph.dest);
+	    }
+	default:
+		return INVALID_PORT;
+	}
+}
+
+#define HASH_IP(map, ip, port) (port + ((ip - ((map)->first_ip)) << 16))
+
+static inline int
+__testip(struct nf_set *set, nf_set_ip_t ip, nf_set_ip_t port)
+{
+	struct nf_set_ipporthash *map = (struct nf_set_ipporthash *) set->data;
+	nf_set_ip_t hash_ip;
+	
+	if (ip < map->first_ip || ip > map->last_ip)
+		return -ERANGE;
+
+	hash_ip = HASH_IP(map, ip, port);
+	DP("set: %s, ipport:%u.%u.%u.%u:%u, %u.%u.%u.%u",
+	   set->name, HIPQUAD(ip), port, HIPQUAD(hash_ip));
+
+	return __iphash_testip(&map->map, hash_ip);	
+}
+
+static int
+testip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_ipporthash *req = 
+	    (struct nf_set_req_ipporthash *) data;
+
+	if (size != sizeof(struct nf_set_req_ipporthash)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_ipporthash),
+			      size);
+		return -EINVAL;
+	}
+	return __testip(set, req->ip, req->port);
+}
+
+static int
+testip_kernel(struct nf_set *set, 
+	      const struct sk_buff *skb,
+	      const u_int32_t *flags)
+{
+	nf_set_ip_t port;
+
+	if (flags[index+1] == 0)
+		return -EINVAL;
+		
+	port = get_port(skb, flags[index+1]);
+
+	DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u",
+	   flags[index] & NFSET_SRC ? "SRC" : "DST",
+	   NIPQUAD(skb->nh.iph->saddr),
+	   NIPQUAD(skb->nh.iph->daddr));
+	DP("flag %s port %u",
+	   flags[index+1] & NFSET_SRC ? "SRC" : "DST", 
+	   port);	
+	if (port == INVALID_PORT)
+		return 0;	
+
+	return __testip(set,
+			ntohl(flags[index] & NFSET_SRC 
+					? skb->nh.iph->saddr 
+					: skb->nh.iph->daddr),
+			port);
+}
+
+static inline int
+__addip(struct nf_set *set, nf_set_ip_t ip, nf_set_ip_t port)
+{
+	struct nf_set_ipporthash *map = 
+		(struct nf_set_ipporthash *) set->data;
+	nf_set_ip_t hash_ip;
+	
+	if (ip < map->first_ip || ip > map->last_ip)
+		return -ERANGE;
+
+	hash_ip = HASH_IP(map, ip, port);
+	DP("set: %s, ipport:%u.%u.%u.%u:%u, %u.%u.%u.%u",
+	   set->name, HIPQUAD(ip), port, HIPQUAD(hash_ip));
+	
+	return __iphash_addip(cache_id, &map->map, hash_ip);	
+}
+
+static int
+addip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_ipporthash *req = 
+	    (struct nf_set_req_ipporthash *) data;
+
+	if (size != sizeof(struct nf_set_req_ipporthash)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_ipporthash),
+			      size);
+		return -EINVAL;
+	}
+	return __addip(set, req->ip, req->port);
+}
+
+static int
+addip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	nf_set_ip_t port;
+
+	if (flags[index+1] == 0)
+		return -EINVAL;
+		
+	port = get_port(skb, flags[index+1]);
+
+	DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u",
+	   flags[index] & NFSET_SRC ? "SRC" : "DST",
+	   NIPQUAD(skb->nh.iph->saddr),
+	   NIPQUAD(skb->nh.iph->daddr));
+	DP("flag %s port %u", 
+	   flags[index+1] & NFSET_SRC ? "SRC" : "DST", 
+	   port);	
+	if (port == INVALID_PORT)
+		return -EINVAL;	
+
+	return __addip(set,
+		       ntohl(flags[index] & NFSET_SRC 
+		       		? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr),
+		       port);
+}
+
+static inline int
+__delip(struct nf_set *set, nf_set_ip_t ip, nf_set_ip_t port)
+{
+	struct nf_set_ipporthash *map = (struct nf_set_ipporthash *) set->data;
+	nf_set_ip_t hash_ip;
+
+	if (ip < map->first_ip || ip > map->last_ip)
+		return -ERANGE;
+
+	hash_ip = HASH_IP(map, ip, port);
+	DP("set: %s, ipport:%u.%u.%u.%u:%u, %u.%u.%u.%u",
+	   set->name, HIPQUAD(ip), port, HIPQUAD(hash_ip));
+	
+	return __iphash_delip(cache_id, &map->map, hash_ip);	
+}
+
+static int
+delip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_ipporthash *req =
+	    (struct nf_set_req_ipporthash *) data;
+
+	if (size != sizeof(struct nf_set_req_ipporthash)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_ipporthash),
+			      size);
+		return -EINVAL;
+	}
+	return __delip(set, req->ip, req->port);
+}
+
+static int
+delip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	nf_set_ip_t port;
+
+	if (flags[index+1] == 0)
+		return -EINVAL;
+		
+	port = get_port(skb, flags[index+1]);
+
+	DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u",
+	   flags[index] & NFSET_SRC ? "SRC" : "DST",
+	   NIPQUAD(skb->nh.iph->saddr),
+	   NIPQUAD(skb->nh.iph->daddr));
+	DP("flag %s port %u",
+	   flags[index+1] & NFSET_SRC ? "SRC" : "DST", 
+	   port);	
+	if (port == INVALID_PORT)
+		return -EINVAL;	
+
+	return __delip(set,
+		       ntohl(flags[index] & NFSET_SRC 
+		       		? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr),
+		       port);
+}
+
+static int create(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_ipporthash_create *req =
+	    (struct nf_set_req_ipporthash_create *) data;
+	struct nf_set_ipporthash *map;
+
+	if (size != sizeof(struct nf_set_req_ipporthash_create)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			       sizeof(struct nf_set_req_ipporthash_create),
+			       size);
+		return -EINVAL;
+	}
+
+	if (req->hashsize < 1) {
+		nf_set_printk("hashsize too small");
+		return -ENOEXEC;
+	}
+
+	if (req->limit < 1) {
+		nf_set_printk("limit too small");
+		return -ENOEXEC;
+	}
+
+	map = kmalloc(sizeof(struct nf_set_ipporthash) 
+		      + req->hashsize * sizeof(struct iphash *), GFP_KERNEL);
+	if (!map) {
+		DP("out of memory for %d bytes",
+		   sizeof(struct nf_set_ipporthash)
+		   + req->hashsize * sizeof(struct iphash *));
+		return -ENOMEM;
+	}
+	memset(map, 0,
+	       sizeof(struct nf_set_ipporthash)
+	       + req->hashsize * sizeof(struct iphash *));
+	map->first_ip = req->from;
+	map->last_ip = req->to;
+	map->map.hashsize = req->hashsize;
+	map->map.limit = req->limit;
+	get_random_bytes(&map->map.initval, 4);
+
+	set->data = map;
+	return 0;
+}
+
+static void destroy(struct nf_set *set)
+{
+	struct nf_set_ipporthash *map = (struct nf_set_ipporthash *) set->data;
+
+	__iphash_destroy(cachep_id, &map->map);
+	kfree(map);
+
+	set->data = NULL;
+}
+
+static void flush(struct nf_set *set)
+{
+	struct nf_set_ipporthash *map = (struct nf_set_ipporthash *) set->data;
+
+	__iphash_flush(cache_id, &map->map);
+}
+
+static void list_header(const struct nf_set *set, void *data)
+{
+	struct nf_set_ipporthash *map = (struct nf_set_ipporthash *) set->data;
+	struct nf_set_req_ipporthash_create *header =
+	    (struct nf_set_req_ipporthash_create *) data;
+
+	header->hashsize = map->map.hashsize;
+	header->limit = map->map.limit;
+	header->from = map->first_ip;
+	header->to = map->last_ip;
+}
+
+static int list_members_size(const struct nf_set *set)
+{
+	struct nf_set_ipporthash *map = (struct nf_set_ipporthash *) set->data;
+
+	return (map->map.count * sizeof(nf_set_ip_t));
+}
+
+static void list_members(const struct nf_set *set, void *data)
+{
+	struct nf_set_ipporthash *map = (struct nf_set_ipporthash *) set->data;
+
+	__iphash_list_members(&map->map, data);
+}
+
+static struct nf_set_type nf_set_ipporthash = {
+	.typename		= SETTYPE_NAME,
+	.features		= NFSET_TYPE_IP | NFSET_TYPE_PORT | NFSET_TYPE_DOUBLE,
+	.subtype_base		= 0,
+	.subtype_next		= 1,
+	.me			= THIS_MODULE,
+	.subtypes		= {
+		[0] = {
+			.create		= &create,
+			.destroy	= &destroy,
+			.flush		= &flush,
+			.reqsize	= sizeof(struct nf_set_req_ipporthash),
+			.addip		= &addip,
+			.addip_kernel	= &addip_kernel,
+			.delip		= &delip,
+			.delip_kernel	= &delip_kernel,
+			.testip		= &testip,
+			.testip_kernel	= &testip_kernel,
+			.list		= &list,
+		},
+	},
+};
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("ipporthash type of IP sets");
+
+static int __init init(void)
+{
+	int ret;
+	
+	ret = nf_set_cache_create(sizeof(struct iphash, &cache_id);
+	if (ret) {
+		printk(KERN_ERR "Unable to create slab cache for nf_set_iphash\n");
+		return ret;
+	}
+	ret = nf_set_register_set_type(&nf_set_ipporthash);
+	if (ret)
+		nf_set_cache_destroy(cache_id);
+
+	return ret;
+}
+
+static void __exit fini(void)
+{
+	/* FIXME: possible race with nf_set_create() */
+	nf_set_unregister_set_type(&nf_set_ipporthash);
+	nf_set_cache_destroy(cache_id);
+}
+
+module_init(init);
+module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/nf_set_iptree.c linux-2.6.15.3-nfset/net/netfilter/nf_set_iptree.c
--- linux-2.6.15.3-orig/net/netfilter/nf_set_iptree.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/nf_set_iptree.c	2006-03-09 00:21:15.000000000 +0100
@@ -0,0 +1,526 @@
+/* Copyright (C) 2005 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* Kernel module implementing an IP set type: the iptree type */
+
+#include <linux/module.h>
+#include <linux/ip.h>
+#include <linux/skbuff.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+
+#include <linux/netfilter/nf_set_iptree.h>
+
+/* Garbage collection interval in seconds: */
+#define IPTREE_GC_TIME		5*60
+/* Sleep so many milliseconds before trying again 
+ * to delete the gc timer at destroying/flushing a set */ 
+#define IPTREE_DESTROY_SLEEP	100
+
+static unsigned int branch_cache_id;
+static unsigned int leaf_cache_id;
+
+#define ABCD(a,b,c,d,addrp) do {		\
+	a = ((unsigned char *)addrp)[3];	\
+	b = ((unsigned char *)addrp)[2];	\
+	c = ((unsigned char *)addrp)[1];	\
+	d = ((unsigned char *)addrp)[0];	\
+} while (0)
+
+#define TESTIP_WALK(map, elem, branch) do {	\
+	if ((map)->tree[elem]) {		\
+		branch = (map)->tree[elem];	\
+	} else 					\
+		return 0;			\
+} while (0)
+
+static inline int
+__testip(struct nf_set *set, nf_set_nf_t ip)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+	struct nf_set_iptreeb *btree;
+	struct nf_set_iptreec *ctree;
+	struct nf_set_iptreed *dtree;
+	unsigned char a,b,c,d;
+	
+	ABCD(a, b, c, d, &ip);
+	DP("%u %u %u %u timeout %u", a, b, c, d, map->timeout);
+	TESTIP_WALK(map, a, btree);
+	TESTIP_WALK(btree, b, ctree);
+	TESTIP_WALK(ctree, c, dtree);
+	DP("%lu %lu", dtree->expires[d], jiffies);
+	return !!(map->timeout ? (time_after(dtree->expires[d], jiffies))
+			       : dtree->expires[d]);
+}
+
+static int
+testip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_iptree *req = 
+	    (struct nf_set_req_iptree *) data;
+
+	if (size != sizeof(struct nf_set_req_iptree)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_iptree),
+			      size);
+		return -EINVAL;
+	}
+	return __testip(set, req->ip);
+}
+
+static int
+testip_kernel(struct nf_set *set, 
+	      const struct sk_buff *skb,
+	      const u_int32_t *flags)
+{
+	int res;
+	
+	DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u",
+	   flags[index] & NFSET_SRC ? "SRC" : "DST",
+	   NIPQUAD(skb->nh.iph->saddr),
+	   NIPQUAD(skb->nh.iph->daddr));
+
+	res =  __testip(set,
+			ntohl(flags[index] & NFSET_SRC 
+				? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+	return (res < 0 ? 0 : res);
+}
+
+#define ADDIP_WALK(map, elem, branch, type, cache_id, flags) do { \
+	if ((map)->tree[elem]) {				\
+		DP("found %u", elem);				\
+		branch = (map)->tree[elem];			\
+	} else {						\
+		branch = (type *)				\
+			nf_set_cache_alloc(cache_id, flags);	\
+		if (branch == NULL)				\
+			return -ENOMEM;				\
+		memset(branch, 0, sizeof(*branch));		\
+		(map)->tree[elem] = branch;			\
+		DP("alloc %u", elem);				\
+	}							\
+} while (0)	
+
+static inline int
+__addip(struct nf_set *set, nf_set_nf_t ip, unsigned int timeout,
+	gfp_t flags)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+	struct nf_set_iptreeb *btree;
+	struct nf_set_iptreec *ctree;
+	struct nf_set_iptreed *dtree;
+	unsigned char a,b,c,d;
+	int ret = 0;
+	
+	if (map->count >= map->limit)
+		return -EOVERFLOW;
+	
+	ABCD(a, b, c, d, &ip);
+	DP("%u %u %u %u timeout %u", a, b, c, d, timeout);
+	ADDIP_WALK(map, a, btree, struct nf_set_iptreeb, branch_cache_id, flags);
+	ADDIP_WALK(btree, b, ctree, struct nf_set_iptreec, branch_cache_id, flags);
+	ADDIP_WALK(ctree, c, dtree, struct nf_set_iptreed, leaf_cache_id, flags);
+	if (dtree->expires[d]
+	    && (!map->timeout || time_after(dtree->expires[d], jiffies)))
+	    	ret = -EEXIST;
+	dtree->expires[d] = map->timeout ? (timeout * HZ + jiffies) : 1;
+	/* Lottery */
+	if (dtree->expires[d] == 0)
+		dtree->expires[d] = 1;
+	DP("%u %lu", d, dtree->expires[d]);
+	return ret;
+}
+
+static int
+addip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+	struct nf_set_req_iptree *req = 
+		(struct nf_set_req_iptree *) data;
+
+	if (size != sizeof(struct nf_set_req_iptree)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_iptree),
+			      size);
+		return -EINVAL;
+	}
+	DP("%u.%u.%u.%u %u", HIPQUAD(req->ip), req->timeout);
+	return __addip(set, req->ip,
+		       req->timeout ? req->timeout : map->timeout,
+		       GFP_ATOMIC);
+}
+
+static int
+addip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+
+	return __addip(set,
+		       ntohl(flags[index] & NFSET_SRC 
+		       		? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr),
+		       map->timeout,
+		       GFP_ATOMIC);
+}
+
+#define DELIP_WALK(map, elem, branch) do {	\
+	if ((map)->tree[elem]) {		\
+		branch = (map)->tree[elem];	\
+	} else 					\
+		return -EEXIST;			\
+} while (0)
+
+static inline int 
+__delip(struct nf_set *set, nf_set_nf_t ip)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+	struct nf_set_iptreeb *btree;
+	struct nf_set_iptreec *ctree;
+	struct nf_set_iptreed *dtree;
+	unsigned char a,b,c,d;
+	
+	ABCD(a, b, c, d, &ip);
+	DELIP_WALK(map, a, btree);
+	DELIP_WALK(btree, b, ctree);
+	DELIP_WALK(ctree, c, dtree);
+
+	if (dtree->expires[d]) {
+		dtree->expires[d] = 0;
+		map->count--;
+		return 0;
+	}
+	return -EEXIST;
+}
+
+static int
+delip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_iptree *req =
+	    (struct nf_set_req_iptree *) data;
+
+	if (size != sizeof(struct nf_set_req_iptree)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_iptree),
+			      size);
+		return -EINVAL;
+	}
+	return __delip(set, req->ip);
+}
+
+static int
+delip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	return __delip(set,
+		       ntohl(flags[index] & NFSET_SRC 
+		       		? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+}
+
+#define LOOP_WALK_BEGIN(map, i, branch) \
+	for (i = 0; i < 256; i++) {	\
+		if (!(map)->tree[i])	\
+			continue;	\
+		branch = (map)->tree[i]
+
+#define LOOP_WALK_END }
+
+static void nf_tree_gc(unsigned long ul_set)
+{
+	struct nf_set *set = (void *) ul_set;
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+	struct nf_set_iptreeb *btree;
+	struct nf_set_iptreec *ctree;
+	struct nf_set_iptreed *dtree;
+	unsigned int a,b,c,d;
+	unsigned char i,j,k;
+
+	i = j = k = 0;
+	DP("gc: %s", set->name);
+	write_lock_bh(&set->lock);
+	LOOP_WALK_BEGIN(map, a, btree);
+	LOOP_WALK_BEGIN(btree, b, ctree);
+	LOOP_WALK_BEGIN(ctree, c, dtree);
+	for (d = 0; d < 256; d++) {
+		if (dtree->expires[d]) {
+			DP("gc: %u %u %u %u: expires %lu jiffies %lu",
+			    a, b, c, d,
+			    dtree->expires[d], jiffies);
+			if (map->timeout
+			    && time_before(dtree->expires[d], jiffies)) {
+			    	dtree->expires[d] = 0;
+			    	map->count--;
+			} else
+				k = 1;
+		}
+	}
+	if (k == 0) {
+		DP("gc: %s: leaf %u %u %u empty",
+		    set->name, a, b, c);
+		nf_set_cache_free(leaf_cache_id, dtree);
+		ctree->tree[c] = NULL;
+	} else {
+		DP("gc: %s: leaf %u %u %u not empty",
+		    set->name, a, b, c);
+		j = 1;
+		k = 0;
+	}
+	LOOP_WALK_END;
+	if (j == 0) {
+		DP("gc: %s: branch %u %u empty",
+		    set->name, a, b);
+		nf_set_cache_free(branch_cache_id, ctree);
+		btree->tree[b] = NULL;
+	} else {
+		DP("gc: %s: branch %u %u not empty",
+		    set->name, a, b);
+		i = 1;
+		j = k = 0;
+	}
+	LOOP_WALK_END;
+	if (i == 0) {
+		DP("gc: %s: branch %u empty",
+		    set->name, a);
+		nf_set_cache_free(branch_cache_id, btree);
+		map->tree[a] = NULL;
+	} else {
+		DP("gc: %s: branch %u not empty",
+		    set->name, a);
+		i = j = k = 0;
+	}
+	LOOP_WALK_END;
+	write_unlock_bh(&set->lock);
+	
+	map->gc.expires = jiffies + map->gc_interval * HZ;
+	add_timer(&map->gc);
+}
+
+static inline void init_gc_timer(struct nf_set *set)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+
+	/* Even if there is no timeout for the entries,
+	 * we still have to call gc because delete
+	 * do not clean up empty branches */
+	map->gc_interval = IPTREE_GC_TIME;
+	init_timer(&map->gc);
+	map->gc.data = (unsigned long) set;
+	map->gc.function = nf_tree_gc;
+	map->gc.expires = jiffies + map->gc_interval * HZ;
+	add_timer(&map->gc);
+}
+
+static int create(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_iptree_create *req =
+	    (struct nf_set_req_iptree_create *) data;
+	struct nf_set_iptree *map;
+
+	if (size != sizeof(struct nf_set_req_iptree_create)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_iptree_create),
+			      size);
+		return -EINVAL;
+	}
+
+	map = kmalloc(sizeof(struct nf_set_iptree), GFP_KERNEL);
+	if (!map) {
+		DP("out of memory for %d bytes",
+		   sizeof(struct nf_set_iptree));
+		return -ENOMEM;
+	}
+	memset(map, 0, sizeof(*map));
+	map->limit = req->limit;
+	map->timeout = req->timeout;
+	set->data = map;
+
+	init_gc_timer(set);
+
+	return 0;
+}
+
+static void __flush(struct nf_set_iptree *map)
+{
+	struct nf_set_iptreeb *btree;
+	struct nf_set_iptreec *ctree;
+	struct nf_set_iptreed *dtree;
+	unsigned int a,b,c;
+
+	LOOP_WALK_BEGIN(map, a, btree);
+	LOOP_WALK_BEGIN(btree, b, ctree);
+	LOOP_WALK_BEGIN(ctree, c, dtree);
+	nf_set_cache_free(leaf_cache_id, dtree);
+	LOOP_WALK_END;
+	nf_set_cache_free(branch_cache_id, ctree);
+	LOOP_WALK_END;
+	nd_set_cache_free(branch_cache_id, btree);
+	LOOP_WALK_END;
+	
+	map->count = 0;
+}
+
+static void destroy(struct nf_set *set)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+
+	/* gc might be running */
+	while (!del_timer(&map->gc))
+		msleep(IPTREE_DESTROY_SLEEP);
+	__flush(map);
+	kfree(map);
+	set->data = NULL;
+}
+
+static void flush(struct nf_set *set)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+	unsigned int timeout = map->timeout;
+	
+	/* gc might be running */
+	while (!del_timer(&map->gc))
+		msleep(IPTREE_DESTROY_SLEEP);
+	__flush(map);
+	memset(map, 0, sizeof(*map));
+	map->timeout = timeout;
+
+	init_gc_timer(set);
+}
+
+static void list_header(const struct nf_set *set, void *data)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+	struct nf_set_req_iptree_create *header =
+	    (struct nf_set_req_iptree_create *) data;
+
+	header->limit = map->limit;
+	header->timeout = map->timeout;
+}
+
+static int list_members_size(const struct nf_set *set)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+	struct nf_set_iptreeb *btree;
+	struct nf_set_iptreec *ctree;
+	struct nf_set_iptreed *dtree;
+	unsigned int a,b,c,d;
+	unsigned int count = 0;
+
+	LOOP_WALK_BEGIN(map, a, btree);
+	LOOP_WALK_BEGIN(btree, b, ctree);
+	LOOP_WALK_BEGIN(ctree, c, dtree);
+	for (d = 0; d < 256; d++) {
+		if (dtree->expires[d]
+		    && (!map->timeout || time_after(dtree->expires[d], jiffies)))
+		    	count++;
+	}
+	LOOP_WALK_END;
+	LOOP_WALK_END;
+	LOOP_WALK_END;
+
+	DP("members %u", count);
+	return (count * sizeof(struct nf_set_req_iptree));
+}
+
+static void list_members(const struct nf_set *set, void *data)
+{
+	struct nf_set_iptree *map = (struct nf_set_iptree *) set->data;
+	struct nf_set_iptreeb *btree;
+	struct nf_set_iptreec *ctree;
+	struct nf_set_iptreed *dtree;
+	unsigned int a,b,c,d;
+	size_t offset = 0;
+	struct nf_set_req_iptree *entry;
+
+	LOOP_WALK_BEGIN(map, a, btree);
+	LOOP_WALK_BEGIN(btree, b, ctree);
+	LOOP_WALK_BEGIN(ctree, c, dtree);
+	for (d = 0; d < 256; d++) {
+		if (dtree->expires[d]
+		    && (!map->timeout || time_after(dtree->expires[d], jiffies))) {
+		    	entry = (struct nf_set_req_iptree *)(data + offset);
+		    	entry->ip = ((a << 24) | (b << 16) | (c << 8) | d);
+		    	entry->timeout = !map->timeout ? 0 
+				: (dtree->expires[d] - jiffies)/HZ;
+			offset += sizeof(struct nf_set_req_iptree);
+		}
+	}
+	LOOP_WALK_END;
+	LOOP_WALK_END;
+	LOOP_WALK_END;
+}
+
+static struct nf_set_type nf_set_iptree = {
+	.typename		= SETTYPE_NAME,
+	.features		= NFSET_TYPE_IP | NFSET_TYPE_SINGLE,
+	.subtype_base		= 0,
+	.subtype_next		= 1,
+	.me			= THIS_MODULE,
+	.subtypes		= {
+		[0] = {
+			.create		= &create,
+			.destroy	= &destroy,
+			.flush		= &flush,
+			.reqsize	= sizeof(struct nf_set_req_iphash),
+			.addip		= &addip,
+			.addip_kernel	= &addip_kernel,
+			.delip		= &delip,
+			.delip_kernel	= &delip_kernel,
+			.testip		= &testip,
+			.testip_kernel	= &testip_kernel,
+			.list		= &list,
+		},
+	},
+};
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("iptree type of IP sets");
+
+static int __init init(void)
+{
+	int ret;
+	
+	ret = nf_set_cache_create(sizeof(struct nf_set_iptreeb),
+				  &branch_cache_id);
+	if (ret) {
+		printk(KERN_ERR "Unable to create nf_set_iptreeb slab cache\n");
+		ret = -ENOMEM;
+		goto out;
+	}
+	ret = nf_set_cache_create(sizeof(struct nf_set_iptreed),
+				  &leaf_cache_id);
+	if (ret) {
+		printk(KERN_ERR "Unable to create nf_set_iptreed slab cache\n");
+		ret = -ENOMEM;
+		goto free_branch;
+	}
+	ret = nf_set_register_set_type(&nf_set_iptree);
+	if (ret == 0)
+		goto out;
+
+	nf_set_cache_destroy(leaf_cache_id);
+    free_branch:	
+	nf_set_cache_destroy(branch_cache_id);
+    out:
+	return ret;
+}
+
+static void __exit fini(void)
+{
+	/* FIXME: possible race with nf_set_create() */
+	nf_set_unregister_set_type(&nf_set_iptree);
+	nf_set_cache_destroy(leaf_cache_id);
+	nf_setcache_destroy(branch_cache_id);
+}
+
+module_init(init);
+module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/nf_set_macipmap.c linux-2.6.15.3-nfset/net/netfilter/nf_set_macipmap.c
--- linux-2.6.15.3-orig/net/netfilter/nf_set_macipmap.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/nf_set_macipmap.c	2006-03-08 23:45:23.000000000 +0100
@@ -0,0 +1,340 @@
+/* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
+ *                         Patrick Schaaf <bof@bof.de>
+ *                         Martin Josefsson <gandalf@wlug.westbo.se>
+ * Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* Kernel module implementing an IP set type: the macipmap type */
+
+#include <linux/module.h>
+#include <linux/ip.h>
+#include <linux/skbuff.h>
+#include <linux/errno.h>
+#include <asm/uaccess.h>
+#include <asm/bitops.h>
+#include <linux/if_ether.h>
+#include <linux/vmalloc.h>
+
+#include <linux/netfilter/nf_set_malloc.h>
+#include <linux/netfilter/nf_set_macipmap.h>
+
+static int
+testip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_macipmap *map = (struct nf_set_macipmap *) set->data;
+	struct nf_set_macip *table = (struct nf_set_macip *) map->members;	
+	struct nf_set_req_macipmap *req = (struct nf_set_req_macipmap *) data;
+
+	if (size != sizeof(struct nf_set_req_macipmap)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_macipmap),
+			      size);
+		return -EINVAL;
+	}
+
+	if (req->ip < map->first_ip || req->ip > map->last_ip)
+		return -ERANGE;
+
+	DP("set: %s, ip:%u.%u.%u.%u",
+	   set->name, HIPQUAD(req->ip));		
+	if (test_bit(NFSET_MACIP_ISSET,
+		     (void *) &table[req->ip - map->first_ip].flags)) {
+		return (memcmp(req->ethernet,
+			       &table[req->ip - map->first_ip].ethernet,
+			       ETH_ALEN) == 0);
+	} else {
+		return (map->flags & NFSET_MACIP_MATCHUNSET ? 1 : 0);
+	}
+}
+
+static int
+testip_kernel(struct nf_set *set, 
+	      const struct sk_buff *skb,
+	      const u_int32_t *flags)
+{
+	struct nf_set_macipmap *map =
+	    (struct nf_set_macipmap *) set->data;
+	struct nf_set_macip *table =
+	    (struct nf_set_macip *) map->members;
+	nf_set_ip_t ip;
+	
+	ip = ntohl(flags[index] & NFSET_SRC
+			? skb->nh.iph->saddr
+			: skb->nh.iph->daddr);
+	DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u",
+	   flags[index] & NFSET_SRC ? "SRC" : "DST",
+	   NIPQUAD(skb->nh.iph->saddr),
+	   NIPQUAD(skb->nh.iph->daddr));
+
+	if (ip < map->first_ip || ip > map->last_ip)
+		return 0;
+
+	DP("set: %s, ip:%u.%u.%u.%u",
+	   set->name, HIPQUAD(ip));		
+	if (test_bit(NFSET_MACIP_ISSET,
+	    (void *) &table[ip - map->first_ip].flags)) {
+		/* Is mac pointer valid?
+		 * If so, compare... */
+		return (skb->mac.raw >= skb->head
+			&& (skb->mac.raw + ETH_HLEN) <= skb->data
+			&& (memcmp(eth_hdr(skb)->h_source,
+				   &table[ip - map->first_ip].ethernet,
+				   ETH_ALEN) == 0));
+	} else {
+		return (map->flags & NFSET_MACIP_MATCHUNSET ? 1 : 0);
+	}
+}
+
+/* returns 0 on success */
+static inline int
+__addip(struct nf_set *set, 
+	nf_set_ip_t ip, unsigned char *ethernet)
+{
+	struct nf_set_macipmap *map =
+	    (struct nf_set_macipmap *) set->data;
+	struct nf_set_macip *table =
+	    (struct nf_set_macip *) map->members;
+
+	if (ip < map->first_ip || ip > map->last_ip)
+		return -ERANGE;
+	if (test_and_set_bit(NFSET_MACIP_ISSET, 
+			     (void *) &table[ip - map->first_ip].flags))
+		return -EEXIST;
+
+	DP("%u.%u.%u.%u", HIPQUAD(ip));
+	memcpy(&table[ip - map->first_ip].ethernet, ethernet, ETH_ALEN);
+	return 0;
+}
+
+static int
+addip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_macipmap *req =
+	    (struct nf_set_req_macipmap *) data;
+
+	if (size != sizeof(struct nf_set_req_macipmap)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_macipmap),
+			      size);
+		return -EINVAL;
+	}
+	return __addip(set, req->ip, req->ethernet);
+}
+
+static int
+addip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	nf_set_ip_t ip;
+	
+	ip = ntohl(flags[index] & NFSET_SRC
+			? skb->nh.iph->saddr
+			: skb->nh.iph->daddr);
+
+	if (!(skb->mac.raw >= skb->head
+	      && (skb->mac.raw + ETH_HLEN) <= skb->data))
+		return -EINVAL;
+
+	return __addip(set, ip, eth_hdr(skb)->h_source);
+}
+
+static inline int
+__delip(struct nf_set *set, nf_set_ip_t ip)
+{
+	struct nf_set_macipmap *map =
+	    (struct nf_set_macipmap *) set->data;
+	struct nf_set_macip *table =
+	    (struct nf_set_macip *) map->members;
+
+	if (ip < map->first_ip || ip > map->last_ip)
+		return -ERANGE;
+
+	DP("%u.%u.%u.%u", HIPQUAD(ip));
+	if (!test_and_clear_bit(NFSET_MACIP_ISSET, 
+				(void *)&table[ip - map->first_ip].flags))
+		return -EEXIST;
+
+	return 0;
+}
+
+static int
+delip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_macipmap *req =
+	    (struct nf_set_req_macipmap *) data;
+
+	if (size != sizeof(struct nf_set_req_macipmap)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_macipmap),
+			      size);
+		return -EINVAL;
+	}
+	return __delip(set, req->ip);
+}
+
+static int
+delip_kernel(struct nf_set *set,
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	return __delip(set,
+		       ntohl(flags[index] & NFSET_SRC 
+		       		? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+}
+
+static inline size_t members_size(nf_set_id_t from, nf_set_id_t to)
+{
+	return (size_t)((to - from + 1) * sizeof(struct nf_set_macip));
+}
+
+static int create(struct nf_set *set, const void *data, size_t size)
+{
+	int newbytes;
+	struct nf_set_req_macipmap_create *req =
+	    (struct nf_set_req_macipmap_create *) data;
+	struct nf_set_macipmap *map;
+
+	if (size != sizeof(struct nf_set_req_macipmap_create)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_macipmap_create),
+			      size);
+		return -EINVAL;
+	}
+
+	DP("from %u.%u.%u.%u to %u.%u.%u.%u",
+	   HIPQUAD(req->from), HIPQUAD(req->to));
+
+	if (req->from > req->to) {
+		DP("bad ip range");
+		return -ENOEXEC;
+	}
+
+	if (req->to - req->from > MAX_RANGE) {
+		nf_set_printk("range too big (max %d addresses)",
+			       MAX_RANGE+1);
+		return -ENOEXEC;
+	}
+
+	map = kmalloc(sizeof(struct nf_set_macipmap), GFP_KERNEL);
+	if (!map) {
+		DP("out of memory for %d bytes",
+		   sizeof(struct nf_set_macipmap));
+		return -ENOMEM;
+	}
+	map->flags = req->flags;
+	map->first_ip = req->from;
+	map->last_ip = req->to;
+	newbytes = members_size(map->first_ip, map->last_ip);
+	map->members = nf_set_malloc(newbytes);
+	DP("members: %u %p", newbytes, map->members);
+	if (!map->members) {
+		DP("out of memory for %d bytes", newbytes);
+		kfree(map);
+		return -ENOMEM;
+	}
+	memset(map->members, 0, newbytes);
+	
+	set->data = map;
+	return 0;
+}
+
+static void destroy(struct nf_set *set)
+{
+	struct nf_set_macipmap *map =
+	    (struct nf_set_macipmap *) set->data;
+
+	nf_set_free(map->members, members_size(map->first_ip, map->last_ip));
+	kfree(map);
+
+	set->data = NULL;
+}
+
+static void flush(struct nf_set *set)
+{
+	struct nf_set_macipmap *map =
+	    (struct nf_set_macipmap *) set->data;
+	memset(map->members, 0, members_size(map->first_ip, map->last_ip));
+}
+
+static void list_header(const struct nf_set *set, void *data)
+{
+	struct nf_set_macipmap *map =
+	    (struct nf_set_macipmap *) set->data;
+	struct nf_set_req_macipmap_create *header =
+	    (struct nf_set_req_macipmap_create *) data;
+
+	DP("list_header %x %x %u", map->first_ip, map->last_ip,
+	   map->flags);
+
+	header->from = map->first_ip;
+	header->to = map->last_ip;
+	header->flags = map->flags;
+}
+
+static int list_members_size(const struct nf_set *set)
+{
+	struct nf_set_macipmap *map =
+	    (struct nf_set_macipmap *) set->data;
+
+	DP("%u", members_size(map->first_ip, map->last_ip));
+	return members_size(map->first_ip, map->last_ip);
+}
+
+static void list_members(const struct nf_set *set, void *data)
+{
+	struct nf_set_macipmap *map =
+	    (struct nf_set_macipmap *) set->data;
+
+	int bytes = members_size(map->first_ip, map->last_ip);
+
+	DP("members: %u %p", bytes, map->members);
+	memcpy(data, map->members, bytes);
+}
+
+static struct nf_set_type nf_set_macipmap = {
+	.typename		= SETTYPE_NAME,
+	.features		= NFSET_TYPE_IP | NFSET_TYPE_SINGLE,
+	.subtype_base		= 0,
+	.subtype_next		= 1,
+	.me			= THIS_MODULE,
+	.subtypes		= {
+		[0] = {
+			.create		= &create,
+			.destroy	= &destroy,
+			.flush		= &flush,
+			.reqsize	= sizeof(struct nf_set_req_macipmap),
+			.addip		= &addip,
+			.addip_kernel	= &addip_kernel,
+			.delip		= &delip,
+			.delip_kernel	= &delip_kernel,
+			.testip		= &testip,
+			.testip_kernel	= &testip_kernel,
+			.list		= &list,
+		},
+	},
+};
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("macipmap type of IP sets");
+
+static int __init init(void)
+{
+	init_max_malloc_size();
+	return nf_set_register_set_type(&nf_set_macipmap);
+}
+
+static void __exit fini(void)
+{
+	/* FIXME: possible race with nf_set_create() */
+	nf_set_unregister_set_type(&nf_set_macipmap);
+}
+
+module_init(init);
+module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/nf_set_nethash.c linux-2.6.15.3-nfset/net/netfilter/nf_set_nethash.c
--- linux-2.6.15.3-orig/net/netfilter/nf_set_nethash.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/nf_set_nethash.c	2006-03-09 08:19:52.000000000 +0100
@@ -0,0 +1,324 @@
+/* Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* Kernel module implementing a cidr nethash set */
+
+#include <linux/module.h>
+#include <linux/ip.h>
+#include <linux/skbuff.h>
+#include <linux/random.h>
+
+#include <net/ip.h>
+
+#include <linux/netfilter/nf_set_malloc.h>
+#include <linux/netfilter/nf_set_nethash.h>
+#include <linux/netfilter/nf_set_jhash.h>
+
+static unsigned int cache_id;
+
+static inline int
+__testip_cidr(struct nf_set *set,
+	      nf_set_ip_t ip,
+	      unsigned char cidr)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+
+	return __iphash_testip(&map->map, pack(ip, cidr));
+}
+
+static inline int
+__testip(struct nf_set *set, nf_set_ip_t ip)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+	int ret = 0;
+
+	for (i = 0; i < 30 && map->cidr[i] && !ret; i++) {
+		ret = hash_ip_cidr(set, ip, map->cidr[i]);
+	}
+	return ret;
+}
+
+static int
+testip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_nethash *req = 
+	    (struct nf_set_req_nethash *) data;
+
+	if (size != sizeof(struct nf_set_req_nethash)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_nethash),
+			      size);
+		return -EINVAL;
+	}
+	return (req->cidr == 32 ? __testip(set, req->ip)
+		: __testip_cidr(set, req->ip, req->cidr));
+}
+
+static int
+testip_kernel(struct nf_set *set, 
+	      const struct sk_buff *skb,
+	      const u_int32_t *flags)
+{
+	return __testip(set,
+			ntohl(flags[index] & NFSET_SRC 
+				? skb->nh.iph->saddr 
+				: skb->nh.iph->daddr));
+}
+
+static inline int
+__addip(struct nf_set_nethash *map, nf_set_ip_t ip, unsigned char cidr)
+{
+	nf_set_ip_t hash_ip = pack(ip, cidr);
+
+	DP("%u.%u.%u.%u/%u, %u.%u.%u.%u", HIPQUAD(ip), cidr, HIPQUAD(hash_ip));
+	return __iphash_addip(cache_id, hash_ip);		
+}
+
+static void
+update_cidr_sizes(struct nf_set_nethash *map, unsigned char cidr)
+{
+	unsigned char next;
+	int i;
+	
+	for (i = 0; i < 30 && map->cidr[i]; i++) {
+		if (map->cidr[i] == cidr) {
+			return;
+		} else if (map->cidr[i] < cidr) {
+			next = map->cidr[i];
+			map->cidr[i] = cidr;
+			cidr = next;
+		}
+	}
+	if (i < 30)
+		map->cidr[i] = cidr;
+}
+
+static int
+addip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+	struct nf_set_req_nethash *req = 
+	    (struct nf_set_req_nethash *) data;
+	int ret;
+
+	if (size != sizeof(struct nf_set_req_nethash)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_nethash),
+			      size);
+		return -EINVAL;
+	}
+	ret = __addip(map, req->ip, req->cidr);
+	
+	if (ret == 0)
+		update_cidr_sizes(map, req->cidr);
+	
+	return ret;
+}
+
+static int
+addip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+	int ret = -ERANGE;
+	nf_set_ip_t ip = ntohl(flags[index] & NFSET_SRC 
+					? skb->nh.iph->saddr
+					: skb->nh.iph->daddr);
+	
+	if (map->cidr[0])
+		ret = __addip(map, ip, map->cidr[0]);
+		
+	return ret;
+}
+
+static inline int
+__delip(struct nf_set_nethash *map, nf_set_ip_t ip, unsigned char cidr)
+{
+	nf_set_ip_t hash_ip = hash_ip_cidr(map, ip, cidr);
+
+	DP("%u.%u.%u.%u/%u, %u.%u.%u.%u", HIPQUAD(ip), cidr, HIPQUAD(hash_ip));
+	return __iphash_delip(cache_id, hash_ip);		
+}
+
+static int
+delip(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+	struct nf_set_req_nethash *req =
+	    (struct nf_set_req_nethash *) data;
+
+	if (size != sizeof(struct nf_set_req_nethash)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_nethash),
+			      size);
+		return -EINVAL;
+	}
+	/* TODO: no garbage collection in map->cidr */		
+	return __delip(map, req->ip, req->cidr);
+}
+
+static int
+delip_kernel(struct nf_set *set, 
+	     const struct sk_buff *skb,
+	     const u_int32_t *flags)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+	int ret = -ERANGE;
+	nf_set_ip_t ip = ntohl(flags[index] & NFSET_SRC 
+					? skb->nh.iph->saddr
+					: skb->nh.iph->daddr);
+	
+	if (map->cidr[0])
+		ret = __delip(map, ip, map->cidr[0]);
+	
+	return ret;
+}
+
+static int create(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_nethash_create *req =
+	    (struct nf_set_req_nethash_create *) data;
+	struct nf_set_nethash *map;
+	uint16_t i;
+
+	if (size != sizeof(struct nf_set_req_nethash_create)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			       sizeof(struct nf_set_req_nethash_create),
+			       size);
+		return -EINVAL;
+	}
+
+	if (req->hashsize < 1) {
+		nf_set_printk("hashsize too small");
+		return -ENOEXEC;
+	}
+	if (req->limit < 1) {
+		nf_set_printk("limit too small");
+		return -ENOEXEC;
+	}
+
+	map = kmalloc(sizeof(struct nf_set_nethash)
+		      + req->hashsize * sizeof(struct iphash *), GFP_KERNEL);
+	if (!map) {
+		DP("out of memory for %d bytes",
+		   sizeof(struct nf_set_nethash)
+		   + req->hashsize * sizeof(struct iphash *));
+		return -ENOMEM;
+	}
+	memset(map, 0,
+	       sizeof(struct nf_set_nethash)
+	       + req->hashsize * sizeof(struct iphash *));
+
+	map->map.hashsize = req->hashsize;
+	map->map.limit = req->limit;
+	get_random_bytes(&map->map.initval, 4);
+	memset(map->cidr, 0, 30 * sizeof(unsigned char));
+	
+	set->data = map;
+	return 0;
+}
+
+static void destroy(struct nf_set *set)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+
+	__iphash_destroy(cache_id, &map->map);
+	kfree(map);
+
+	set->data = NULL;
+}
+
+static void flush(struct nf_set *set)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+
+	__iphash_flush(cache_id, &map->map);
+	memset(map->cidr, 0, 30 * sizeof(unsigned char));
+}
+
+static void list_header(const struct nf_set *set, void *data)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+	struct nf_set_req_nethash_create *header =
+	    (struct nf_set_req_nethash_create *) data;
+
+	header->hashsize = map->hashsize;
+	header->probes = map->probes;
+	header->resize = map->resize;
+}
+
+static int list_members_size(const struct nf_set *set)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+
+	return (map->hashsize * sizeof(nf_set_ip_t));
+}
+
+static void list_members(const struct nf_set *set, void *data)
+{
+	struct nf_set_nethash *map = (struct nf_set_nethash *) set->data;
+	nf_set_ip_t i, *elem;
+
+	for (i = 0; i < map->hashsize; i++) {
+		elem = HARRAY_ELEM(map->members, nf_set_ip_t *, i);	
+		((nf_set_ip_t *)data)[i] = *elem;
+	}
+}
+
+static struct nf_set_type nf_set_nethash = {
+	.typename		= SETTYPE_NAME,
+	.features		= NFSET_TYPE_IP | NFSET_TYPE_SINGLE,
+	.subtype_base		= 0,
+	.subtype_next		= 1,
+	.me			= THIS_MODULE,
+	.subtypes		= {
+		[0] = {
+			.create		= &create,
+			.destroy	= &destroy,
+			.flush		= &flush,
+			.reqsize	= sizeof(struct nf_set_req_nethash),
+			.addip		= &addip,
+			.addip_kernel	= &addip_kernel,
+			.delip		= &delip,
+			.delip_kernel	= &delip_kernel,
+			.testip		= &testip,
+			.testip_kernel	= &testip_kernel,
+			.list		= &list,
+		},
+	},
+};
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("nethash type of IP sets");
+
+static int __init init(void)
+{
+	int ret;
+	
+	ret = nf_set_cache_create(sizeof(struct iphash), &cache_id);
+	if (ret) {
+		printk(KERN_ERR "Unable to create slab cache for nf_set_iphash\n");
+		return ret;
+	}
+	ret = nf_set_register_set_type(&nf_set_nethash);
+	if (ret)
+		nf_set_cache_destroy(cache_id);
+
+	return ret;
+}
+
+static void __exit fini(void)
+{
+	/* FIXME: possible race with nf_set_create() */
+	nf_set_unregister_set_type(&nf_set_nethash);
+	nf_set_cache_destroy(cache_id);
+}
+
+module_init(init);
+module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-orig/net/netfilter/nf_set_portmap.c linux-2.6.15.3-nfset/net/netfilter/nf_set_portmap.c
--- linux-2.6.15.3-orig/net/netfilter/nf_set_portmap.c	1970-01-01 01:00:00.000000000 +0100
+++ linux-2.6.15.3-nfset/net/netfilter/nf_set_portmap.c	2006-03-09 00:01:35.000000000 +0100
@@ -0,0 +1,319 @@
+/* Copyright (C) 2003-2004 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  
+ */
+
+/* Kernel module implementing a port set type as a bitmap */
+
+#include <linux/module.h>
+#include <linux/ip.h>
+#include <linux/tcp.h>
+#include <linux/udp.h>
+#include <linux/skbuff.h>
+#include <linux/errno.h>
+
+#include <net/ip.h>
+
+#include <linux/netfilter/nf_set_portmap.h>
+
+/* We must handle non-linear skbs */
+static inline nf_set_ip_t
+get_port(const struct sk_buff *skb, u_int32_t flags)
+{
+	struct iphdr *iph = skb->nh.iph;
+	u_int16_t offset = ntohs(iph->frag_off) & IP_OFFSET;
+
+	switch (iph->protocol) {
+	case IPPROTO_TCP: {
+		struct tcphdr tcph;
+		
+		/* See comments at tcp_match in ip_tables.c */
+		if (offset)
+			return INVALID_PORT;
+
+		if (skb_copy_bits(skb, skb->nh.iph->ihl*4, &tcph, sizeof(tcph)) < 0)
+			/* No choice either */
+			return INVALID_PORT;
+	     	
+	     	return ntohs(flags & NFSET_SRC ?
+			     tcph.source : tcph.dest);
+	    }
+	case IPPROTO_UDP: {
+		struct udphdr udph;
+
+		if (offset)
+			return INVALID_PORT;
+
+		if (skb_copy_bits(skb, skb->nh.iph->ihl*4, &udph, sizeof(udph)) < 0)
+			/* No choice either */
+			return INVALID_PORT;
+	     	
+	     	return ntohs(flags & NFSET_SRC ?
+			     udph.source : udph.dest);
+	    }
+	default:
+		return INVALID_PORT;
+	}
+}
+
+static inline int
+__testport(struct nf_set *set, nf_set_ip_t port)
+{
+	struct nf_set_portmap *map = (struct nf_set_portmap *) set->data;
+
+	if (port < map->first_port || port > map->last_port)
+		return -ERANGE;
+		
+	DP("set: %s, port:%u", set->name, port);
+	return !!test_bit(port - map->first_port, map->members);
+}
+
+static int
+testport(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_portmap *req = 
+	    (struct nf_set_req_portmap *) data;
+
+	if (size != sizeof(struct nf_set_req_portmap)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_portmap),
+			      size);
+		return -EINVAL;
+	}
+	return __testport(set, req->port);
+}
+
+static int
+testport_kernel(struct nf_set *set, 
+	        const struct sk_buff *skb,
+	        const u_int32_t *flags)
+{
+	int res;
+	nf_set_ip_t port = get_port(skb, flags[index]);
+
+	DP("flag %s port %u", flags[index] & NFSET_SRC ? "SRC" : "DST", port);	
+	if (port == INVALID_PORT)
+		return 0;	
+
+	res =  __testport(set, port);
+	
+	return (res < 0 ? 0 : res);
+}
+
+static inline int
+__addport(struct nf_set *set, nf_set_ip_t port)
+{
+	struct nf_set_portmap *map = (struct nf_set_portmap *) set->data;
+
+	if (port < map->first_port || port > map->last_port)
+		return -ERANGE;
+	if (test_and_set_bit(port - map->first_port, map->members))
+		return -EEXIST;
+		
+	DP("port %u", port);
+	return 0;
+}
+
+static int
+addport(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_portmap *req = 
+	    (struct nf_set_req_portmap *) data;
+
+	if (size != sizeof(struct nf_set_req_portmap)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_portmap),
+			      size);
+		return -EINVAL;
+	}
+	return __addport(set, req->port);
+}
+
+static int
+addport_kernel(struct nf_set *set, 
+	       const struct sk_buff *skb,
+	       const u_int32_t *flags)
+{
+	nf_set_ip_t port = get_port(skb, flags[index]);
+	
+	if (port == INVALID_PORT)
+		return -EINVAL;
+
+	return __addport(set, port);
+}
+
+static inline int
+__delport(struct nf_set *set, nf_set_ip_t port)
+{
+	struct nf_set_portmap *map = (struct nf_set_portmap *) set->data;
+
+	if (port < map->first_port || port > map->last_port)
+		return -ERANGE;
+	if (!test_and_clear_bit(port - map->first_port, map->members))
+		return -EEXIST;
+		
+	DP("port %u", port);
+	return 0;
+}
+
+static int
+delport(struct nf_set *set, const void *data, size_t size)
+{
+	struct nf_set_req_portmap *req =
+	    (struct nf_set_req_portmap *) data;
+
+	if (size != sizeof(struct nf_set_req_portmap)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			      sizeof(struct nf_set_req_portmap),
+			      size);
+		return -EINVAL;
+	}
+	return __delport(set, req->port);
+}
+
+static int
+delport_kernel(struct nf_set *set, 
+	       const struct sk_buff *skb,
+	       const u_int32_t *flags)
+{
+	nf_set_ip_t port = get_port(skb, flags[index]);
+	
+	if (port == INVALID_PORT)
+		return -EINVAL;
+
+	return __delport(set, port);
+}
+
+static int create(struct nf_set *set, const void *data, size_t size)
+{
+	int newbytes;
+	struct nf_set_req_portmap_create *req =
+	    (struct nf_set_req_portmap_create *) data;
+	struct nf_set_portmap *map;
+
+	if (size != sizeof(struct nf_set_req_portmap_create)) {
+		nf_set_printk("data length wrong (want %zu, have %zu)",
+			       sizeof(struct nf_set_req_portmap_create),
+			       size);
+		return -EINVAL;
+	}
+
+	DP("from %u to %u", req->from, req->to);
+
+	if (req->from > req->to) {
+		DP("bad port range");
+		return -ENOEXEC;
+	}
+
+	if (req->to - req->from > MAX_RANGE) {
+		nf_set_printk("range too big (max %d ports)",
+			       MAX_RANGE+1);
+		return -ENOEXEC;
+	}
+
+	map = kmalloc(sizeof(struct nf_set_portmap), GFP_KERNEL);
+	if (!map) {
+		DP("out of memory for %d bytes",
+		   sizeof(struct nf_set_portmap));
+		return -ENOMEM;
+	}
+	map->first_port = req->from;
+	map->last_port = req->to;
+	newbytes = bitmap_bytes(req->from, req->to);
+	map->members = kmalloc(newbytes, GFP_KERNEL);
+	if (!map->members) {
+		DP("out of memory for %d bytes", newbytes);
+		kfree(map);
+		return -ENOMEM;
+	}
+	memset(map->members, 0, newbytes);
+
+	set->data = map;
+	return 0;
+}
+
+static void destroy(struct nf_set *set)
+{
+	struct nf_set_portmap *map = (struct nf_set_portmap *) set->data;
+
+	kfree(map->members);
+	kfree(map);
+
+	set->data = NULL;
+}
+
+static void flush(struct nf_set *set)
+{
+	struct nf_set_portmap *map = (struct nf_set_portmap *) set->data;
+	memset(map->members, 0, bitmap_bytes(map->first_port, map->last_port));
+}
+
+static void list_header(const struct nf_set *set, void *data)
+{
+	struct nf_set_portmap *map = (struct nf_set_portmap *) set->data;
+	struct nf_set_req_portmap_create *header =
+	    (struct nf_set_req_portmap_create *) data;
+
+	DP("list_header %u %u", map->first_port, map->last_port);
+
+	header->from = map->first_port;
+	header->to = map->last_port;
+}
+
+static int list_members_size(const struct nf_set *set)
+{
+	struct nf_set_portmap *map = (struct nf_set_portmap *) set->data;
+
+	return bitmap_bytes(map->first_port, map->last_port);
+}
+
+static void list_members(const struct nf_set *set, void *data)
+{
+	struct nf_set_portmap *map = (struct nf_set_portmap *) set->data;
+	int bytes = bitmap_bytes(map->first_port, map->last_port);
+
+	memcpy(data, map->members, bytes);
+}
+
+static struct nf_set_type nf_set_portmap = {
+	.typename		= SETTYPE_NAME,
+	.features		= NFSET_TYPE_PORT | NFSET_TYPE_SINGLE,
+	.subtype_base		= 0,
+	.subtype_next		= 1,
+	.me			= THIS_MODULE,
+	.subtypes		= {
+		[0] = {
+			.create		= &create,
+			.destroy	= &destroy,
+			.flush		= &flush,
+			.reqsize	= sizeof(struct nf_set_req_portmap),
+			.addip		= &addport,
+			.addip_kernel	= &addport_kernel,
+			.delip		= &delport,
+			.delip_kernel	= &delport_kernel,
+			.testip		= &testport,
+			.testip_kernel	= &testport_kernel,
+			.list		= &list,
+		},
+	},
+};
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
+MODULE_DESCRIPTION("portmap type of IP sets");
+
+static int __init init(void)
+{
+	return nf_set_register_set_type(&nf_set_portmap);
+}
+
+static void __exit fini(void)
+{
+	/* FIXME: possible race with nf_set_create() */
+	nf_set_unregister_set_type(&nf_set_portmap);
+}
+
+module_init(init);
+module_exit(fini);
