diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter/nf_set.h linux-2.6.15.3-nfset/include/linux/netfilter/nf_set.h
--- linux-2.6.15.3-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/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-ipset/include/linux/netfilter/nfnetlink.h linux-2.6.15.3-nfset/include/linux/netfilter/nfnetlink.h
--- linux-2.6.15.3-ipset/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-ipset/include/linux/netfilter/nfnetlink_set.h linux-2.6.15.3-nfset/include/linux/netfilter/nfnetlink_set.h
--- linux-2.6.15.3-ipset/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-ipset/include/linux/netfilter_ipv4/ip_set.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,498 +0,0 @@
-#ifndef _IP_SET_H
-#define _IP_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 0
-#define IP_SET_DEBUG
-#endif
-
-/*
- * A sockopt of such quality has hardly ever been seen before on the open
- * market!  This little beauty, hardly ever used: above 64, so it's
- * traditionally used for firewalling, not touched (even once!) by the
- * 2.0, 2.2 and 2.4 kernels!
- *
- * Comes with its own certificate of authenticity, valid anywhere in the
- * Free world!
- *
- * Rusty, 19.4.2000
- */
-#define SO_IP_SET 		83
-
-/*
- * Heavily modify by Joakim Axelsson 08.03.2002
- * - Made it more modulebased
- *
- * Additional heavy modifications by Jozsef Kadlecsik 22.02.2004
- * - bindings added
- * - in order to "deal with" backward compatibility, renamed to ipset
- */
-
-/* 
- * Used so that the kernel module and ipset-binary can match their versions 
- */
-#define IP_SET_PROTOCOL_VERSION 2
-
-#define IP_SET_MAXNAMELEN 32	/* set names and set typenames */
-
-/* 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 ip_set_ip_t;
-
-/* Sets are identified by an id in kernel space. Tweak with ip_set_id_t
- * and IP_SET_INVALID_ID if you want to increase the max number of sets.
- */
-typedef uint16_t ip_set_id_t;
-
-#define IP_SET_INVALID_ID	65535
-
-/* How deep we follow bindings */
-#define IP_SET_MAX_BINDINGS	6
-
-/*
- * Option flags for kernel operations (ipt_set_info)
- */
-#define IPSET_SRC 		0x01	/* Source match/add */
-#define IPSET_DST		0x02	/* Destination match/add */
-#define IPSET_MATCH_INV		0x04	/* Inverse matching */
-
-/*
- * Set features
- */
-#define IPSET_TYPE_IP		0x01	/* IP address type of set */
-#define IPSET_TYPE_PORT		0x02	/* Port type of set */
-#define IPSET_DATA_SINGLE	0x04	/* Single data storage */
-#define IPSET_DATA_DOUBLE	0x08	/* Double data storage */
-
-/* Reserved keywords */
-#define IPSET_TOKEN_DEFAULT	":default:"
-#define IPSET_TOKEN_ALL		":all:"
-
-/* SO_IP_SET operation constants, and their request struct types.
- *
- * Operation ids:
- *	  0-99:	 commands with version checking
- *	100-199: add/del/test/bind/unbind
- *	200-299: list, save, restore
- */
-
-/* Single shot operations: 
- * version, create, destroy, flush, rename and swap 
- *
- * Sets are identified by name.
- */
-
-#define IP_SET_REQ_STD		\
-	unsigned op;		\
-	unsigned version;	\
-	char name[IP_SET_MAXNAMELEN]
-
-#define IP_SET_OP_CREATE	0x00000001	/* Create a new (empty) set */
-struct ip_set_req_create {
-	IP_SET_REQ_STD;
-	char typename[IP_SET_MAXNAMELEN];
-};
-
-#define IP_SET_OP_DESTROY	0x00000002	/* Remove a (empty) set */
-struct ip_set_req_std {
-	IP_SET_REQ_STD;
-};
-
-#define IP_SET_OP_FLUSH		0x00000003	/* Remove all IPs in a set */
-/* Uses ip_set_req_std */
-
-#define IP_SET_OP_RENAME	0x00000004	/* Rename a set */
-/* Uses ip_set_req_create */
-
-#define IP_SET_OP_SWAP		0x00000005	/* Swap two sets */
-/* Uses ip_set_req_create */
-
-union ip_set_name_index {
-	char name[IP_SET_MAXNAMELEN];
-	ip_set_id_t index;
-};
-
-#define IP_SET_OP_GET_BYNAME	0x00000006	/* Get set index by name */
-struct ip_set_req_get_set {
-	unsigned op;
-	unsigned version;
-	union ip_set_name_index set;
-};
-
-#define IP_SET_OP_GET_BYINDEX	0x00000007	/* Get set name by index */
-/* Uses ip_set_req_get_set */
-
-#define IP_SET_OP_VERSION	0x00000100	/* Ask kernel version */
-struct ip_set_req_version {
-	unsigned op;
-	unsigned version;
-};
-
-/* Double shots operations: 
- * add, del, test, bind and unbind.
- *
- * First we query the kernel to get the index and type of the target set,
- * then issue the command. Validity of IP is checked in kernel in order
- * to minimalize sockopt operations.
- */
-
-/* Get minimal set data for add/del/test/bind/unbind IP */
-#define IP_SET_OP_ADT_GET	0x00000010	/* Get set and type */
-struct ip_set_req_adt_get {
-	unsigned op;
-	unsigned version;
-	union ip_set_name_index set;
-	char typename[IP_SET_MAXNAMELEN];
-};
-
-#define IP_SET_REQ_BYINDEX	\
-	unsigned op;		\
-	ip_set_id_t index;
-
-struct ip_set_req_adt {
-	IP_SET_REQ_BYINDEX;
-};
-
-#define IP_SET_OP_ADD_IP	0x00000101	/* Add an IP to a set */
-/* Uses ip_set_req_adt, with type specific addage */
-
-#define IP_SET_OP_DEL_IP	0x00000102	/* Remove an IP from a set */
-/* Uses ip_set_req_adt, with type specific addage */
-
-#define IP_SET_OP_TEST_IP	0x00000103	/* Test an IP in a set */
-/* Uses ip_set_req_adt, with type specific addage */
-
-#define IP_SET_OP_BIND_SET	0x00000104	/* Bind an IP to a set */
-/* Uses ip_set_req_bind, with type specific addage */
-struct ip_set_req_bind {
-	IP_SET_REQ_BYINDEX;
-	char binding[IP_SET_MAXNAMELEN];
-};
-
-#define IP_SET_OP_UNBIND_SET	0x00000105	/* Unbind an IP from a set */
-/* Uses ip_set_req_bind, with type speficic addage 
- * index = 0 means unbinding for all sets */
-
-#define IP_SET_OP_TEST_BIND_SET	0x00000106	/* Test binding an IP to a set */
-/* Uses ip_set_req_bind, with type specific addage */
-
-/* Multiple shots operations: list, save, restore.
- *
- * - check kernel version and query the max number of sets
- * - get the basic information on all sets
- *   and size required for the next step
- * - get actual set data: header, data, bindings
- */
-
-/* Get max_sets and the index of a queried set
- */
-#define IP_SET_OP_MAX_SETS	0x00000020
-struct ip_set_req_max_sets {
-	unsigned op;
-	unsigned version;
-	ip_set_id_t max_sets;		/* max_sets */
-	ip_set_id_t sets;		/* real number of sets */
-	union ip_set_name_index set;	/* index of set if name used */
-};
-
-/* Get the id and name of the sets plus size for next step */
-#define IP_SET_OP_LIST_SIZE	0x00000201
-#define IP_SET_OP_SAVE_SIZE	0x00000202
-struct ip_set_req_setnames {
-	unsigned op;
-	ip_set_id_t index;		/* set to list/save */
-	size_t size;			/* size to get setdata/bindings */
-	/* followed by sets number of struct ip_set_name_list */
-};
-
-struct ip_set_name_list {
-	char name[IP_SET_MAXNAMELEN];
-	char typename[IP_SET_MAXNAMELEN];
-	ip_set_id_t index;
-	ip_set_id_t id;
-};
-
-/* The actual list operation */
-#define IP_SET_OP_LIST		0x00000203
-struct ip_set_req_list {
-	IP_SET_REQ_BYINDEX;
-	/* sets number of struct ip_set_list in reply */ 
-};
-
-struct ip_set_list {
-	ip_set_id_t index;
-	ip_set_id_t binding;
-	u_int32_t ref;
-	size_t header_size;	/* Set header data of header_size */
-	size_t members_size;	/* Set members data of members_size */
-	size_t bindings_size;	/* Set bindings data of bindings_size */
-};
-
-struct ip_set_hash_list {
-	ip_set_ip_t ip;
-	ip_set_id_t binding;
-};
-
-/* The save operation */
-#define IP_SET_OP_SAVE		0x00000204
-/* Uses ip_set_req_list, in the reply replaced by
- * sets number of struct ip_set_save plus a marker
- * ip_set_save followed by ip_set_hash_save structures.
- */
-struct ip_set_save {
-	ip_set_id_t index;
-	ip_set_id_t binding;
-	size_t header_size;	/* Set header data of header_size */
-	size_t members_size;	/* Set members data of members_size */
-};
-
-/* At restoring, ip == 0 means default binding for the given set: */
-struct ip_set_hash_save {
-	ip_set_ip_t ip;
-	ip_set_id_t id;
-	ip_set_id_t binding;
-};
-
-/* The restore operation */
-#define IP_SET_OP_RESTORE	0x00000205
-/* Uses ip_set_req_setnames followed by ip_set_restore structures
- * plus a marker ip_set_restore, followed by ip_set_hash_save 
- * structures.
- */
-struct ip_set_restore {
-	char name[IP_SET_MAXNAMELEN];
-	char typename[IP_SET_MAXNAMELEN];
-	ip_set_id_t index;
-	size_t header_size;	/* Create data of header_size */
-	size_t members_size;	/* Set members data of members_size */
-};
-
-static inline int bitmap_bytes(ip_set_ip_t a, ip_set_ip_t b)
-{
-	return 4 * ((((b - a + 8) / 8) + 3) / 4);
-}
-
-#ifdef __KERNEL__
-
-#define ip_set_printk(format, args...) 			\
-	do {							\
-		printk("%s: %s: ", __FILE__, __FUNCTION__);	\
-		printk(format "\n" , ## args);			\
-	} while (0)
-
-#if defined(IP_SET_DEBUG)
-#define DP(format, args...) 					\
-	do {							\
-		printk("%s: %s (DBG): ", __FILE__, __FUNCTION__);\
-		printk(format "\n" , ## args);			\
-	} while (0)
-#define IP_SET_ASSERT(x)					\
-	do {							\
-		if (!(x))					\
-			printk("IP_SET_ASSERT: %s:%i(%s)\n",	\
-				__FILE__, __LINE__, __FUNCTION__); \
-	} while (0)
-#else
-#define DP(format, args...)
-#define IP_SET_ASSERT(x)
-#endif
-
-struct ip_set;
-
-/*
- * The ip_set_type definition - one per set type, e.g. "ipmap".
- *
- * Each individual set has a pointer, set->type, 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 ip_set_type {
-	struct list_head list;	/* next in list of set types */
-
-	/* test for IP in set (kernel: iptables -m set src|dst)
-	 * return 0 if not in set, 1 if in set.
-	 */
-	int (*testip_kernel) (struct ip_set *set,
-			      const struct sk_buff * skb, 
-			      ip_set_ip_t *ip,
-			      const u_int32_t *flags,
-			      unsigned char index);
-
-	/* test for IP in set (userspace: ipset -T set IP)
-	 * return 0 if not in set, 1 if in set.
-	 */
-	int (*testip) (struct ip_set *set,
-		       const void *data, size_t size,
-		       ip_set_ip_t *ip);
-
-	/*
-	 * Size of the data structure passed by when
-	 * adding/deletin/testing an entry.
-	 */
-	size_t reqsize;
-
-	/* Add IP into set (userspace: ipset -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 (*addip) (struct ip_set *set, 
-		      const void *data, size_t size,
-		      ip_set_ip_t *ip);
-
-	/* 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 (*addip_kernel) (struct ip_set *set,
-			     const struct sk_buff * skb, 
-			     ip_set_ip_t *ip,
-			     const u_int32_t *flags,
-			     unsigned char index);
-
-	/* remove IP from set (userspace: ipset -D set --entry 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 (*delip) (struct ip_set *set, 
-		      const void *data, size_t size,
-		      ip_set_ip_t *ip);
-
-	/* remove IP from set (kernel: iptables ... -j SET --entry 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 (*delip_kernel) (struct ip_set *set,
-			     const struct sk_buff * skb, 
-			     ip_set_ip_t *ip,
-			     const u_int32_t *flags,
-			     unsigned char index);
-
-	/* new set creation - allocated type specific items
-	 */
-	int (*create) (struct ip_set *set,
-		       const void *data, size_t size);
-
-	/* retry the operation after successfully tweaking the set
-	 */
-	int (*retry) (struct ip_set *set);
-
-	/* set destruction - free type specific items
-	 * There is no return value.
-	 * Can be called only when child sets are destroyed.
-	 */
-	void (*destroy) (struct ip_set *set);
-
-	/* set flushing - reset all bits in the set, or something similar.
-	 * There is no return value.
-	 */
-	void (*flush) (struct ip_set *set);
-
-	/* Listing: size needed for header
-	 */
-	size_t header_size;
-
-	/* 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 ip_set *set, 
-			     void *data);
-
-	/* Listing: Get the size for the set members
-	 */
-	int (*list_members_size) (const struct ip_set *set);
-
-	/* 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. 
-	 */
-	void (*list_members) (const struct ip_set *set,
-			      void *data);
-
-	char typename[IP_SET_MAXNAMELEN];
-	unsigned char features;
-	int protocol_version;
-
-	/* Set this to THIS_MODULE if you are a module, otherwise NULL */
-	struct module *me;
-};
-
-extern int ip_set_register_set_type(struct ip_set_type *set_type);
-extern void ip_set_unregister_set_type(struct ip_set_type *set_type);
-
-/* A generic ipset */
-struct ip_set {
-	char name[IP_SET_MAXNAMELEN];	/* the name of the set */
-	rwlock_t lock;			/* lock for concurrency control */
-	ip_set_id_t id;			/* set id for swapping */
-	ip_set_id_t binding;		/* default binding for the set */
-	atomic_t ref;			/* in kernel and in hash references */
-	struct ip_set_type *type; 	/* the set types */
-	void *data;			/* pooltype specific data */
-};
-
-/* Structure to bind set elements to sets */
-struct ip_set_hash {
-	struct list_head list;		/* list of clashing entries in hash */
-	ip_set_ip_t ip;			/* ip from set */
-	ip_set_id_t id;			/* set id */
-	ip_set_id_t binding;		/* set we bind the element to */
-};
-
-/* register and unregister set references */
-extern ip_set_id_t ip_set_get_byname(const char name[IP_SET_MAXNAMELEN]);
-extern ip_set_id_t ip_set_get_byindex(ip_set_id_t id);
-extern void ip_set_put(ip_set_id_t id);
-
-/* API for iptables set match, and SET target */
-extern void ip_set_addip_kernel(ip_set_id_t id,
-				const struct sk_buff *skb,
-				const u_int32_t *flags);
-extern void ip_set_delip_kernel(ip_set_id_t id,
-				const struct sk_buff *skb,
-				const u_int32_t *flags);
-extern int ip_set_testip_kernel(ip_set_id_t id,
-				const struct sk_buff *skb,
-				const u_int32_t *flags);
-
-#endif				/* __KERNEL__ */
-
-#endif /*_IP_SET_H*/
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_iphash.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_iphash.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_iphash.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_iphash.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,29 +0,0 @@
-#ifndef __IP_SET_IPHASH_H
-#define __IP_SET_IPHASH_H
-
-#include <linux/netfilter_ipv4/ip_set.h>
-
-#define SETTYPE_NAME "iphash"
-#define MAX_RANGE 0x0000FFFF
-
-struct ip_set_iphash {
-	ip_set_ip_t *members;		/* the iphash proper */
-	uint32_t hashsize;		/* hash size */
-	uint16_t probes;		/* max number of probes  */
-	uint16_t resize;		/* resize factor in percent */
-	ip_set_ip_t netmask;		/* netmask */
-	void *initval[0];		/* initvals for jhash_1word */
-};
-
-struct ip_set_req_iphash_create {
-	uint32_t hashsize;
-	uint16_t probes;
-	uint16_t resize;
-	ip_set_ip_t netmask;
-};
-
-struct ip_set_req_iphash {
-	ip_set_ip_t ip;
-};
-
-#endif	/* __IP_SET_IPHASH_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_ipmap.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_ipmap.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_ipmap.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_ipmap.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,56 +0,0 @@
-#ifndef __IP_SET_IPMAP_H
-#define __IP_SET_IPMAP_H
-
-#include <linux/netfilter_ipv4/ip_set.h>
-
-#define SETTYPE_NAME "ipmap"
-#define MAX_RANGE 0x0000FFFF
-
-struct ip_set_ipmap {
-	void *members;			/* the ipmap proper */
-	ip_set_ip_t first_ip;		/* host byte order, included in range */
-	ip_set_ip_t last_ip;		/* host byte order, included in range */
-	ip_set_ip_t netmask;		/* subnet netmask */
-	ip_set_ip_t sizeid;		/* size of set in IPs */
-	ip_set_ip_t hosts;		/* number of hosts in a subnet */
-};
-
-struct ip_set_req_ipmap_create {
-	ip_set_ip_t from;
-	ip_set_ip_t to;
-	ip_set_ip_t netmask;
-};
-
-struct ip_set_req_ipmap {
-	ip_set_ip_t ip;
-};
-
-unsigned int
-mask_to_bits(ip_set_ip_t mask)
-{
-	unsigned int bits = 32;
-	ip_set_ip_t maskaddr;
-	
-	if (mask == 0xFFFFFFFF)
-		return bits;
-	
-	maskaddr = 0xFFFFFFFE;
-	while (--bits >= 0 && maskaddr != mask)
-		maskaddr <<= 1;
-	
-	return bits;
-}
-
-ip_set_ip_t
-range_to_mask(ip_set_ip_t from, ip_set_ip_t to, unsigned int *bits)
-{
-	ip_set_ip_t mask = 0xFFFFFFFE;
-	
-	*bits = 32;
-	while (--(*bits) >= 0 && mask && (to & mask) != from)
-		mask <<= 1;
-		
-	return mask;
-}
-	
-#endif /* __IP_SET_IPMAP_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_ipporthash.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_ipporthash.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_ipporthash.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_ipporthash.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,33 +0,0 @@
-#ifndef __IP_SET_IPPORTHASH_H
-#define __IP_SET_IPPORTHASH_H
-
-#include <linux/netfilter_ipv4/ip_set.h>
-
-#define SETTYPE_NAME "ipporthash"
-#define MAX_RANGE 0x0000FFFF
-#define INVALID_PORT	(MAX_RANGE + 1)
-
-struct ip_set_ipporthash {
-	ip_set_ip_t *members;		/* the ipporthash proper */
-	uint32_t hashsize;		/* hash size */
-	uint16_t probes;		/* max number of probes  */
-	uint16_t resize;		/* resize factor in percent */
-	ip_set_ip_t first_ip;		/* host byte order, included in range */
-	ip_set_ip_t last_ip;		/* host byte order, included in range */
-	void *initval[0];		/* initvals for jhash_1word */
-};
-
-struct ip_set_req_ipporthash_create {
-	uint32_t hashsize;
-	uint16_t probes;
-	uint16_t resize;
-	ip_set_ip_t from;
-	ip_set_ip_t to;
-};
-
-struct ip_set_req_ipporthash {
-	ip_set_ip_t ip;
-	ip_set_ip_t port;
-};
-
-#endif	/* __IP_SET_IPPORTHASH_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_iptree.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_iptree.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_iptree.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_iptree.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,39 +0,0 @@
-#ifndef __IP_SET_IPTREE_H
-#define __IP_SET_IPTREE_H
-
-#include <linux/netfilter_ipv4/ip_set.h>
-
-#define SETTYPE_NAME "iptree"
-#define MAX_RANGE 0x0000FFFF
-
-struct ip_set_iptreed {
-	unsigned long expires[256];	   	/* x.x.x.ADDR */
-};
-
-struct ip_set_iptreec {
-	struct ip_set_iptreed *tree[256];	/* x.x.ADDR.* */
-};
-
-struct ip_set_iptreeb {
-	struct ip_set_iptreec *tree[256];	/* x.ADDR.*.* */
-};
-
-struct ip_set_iptree {
-	unsigned int timeout;
-	unsigned int gc_interval;
-#ifdef __KERNEL__
-	struct timer_list gc;
-	struct ip_set_iptreeb *tree[256];	/* ADDR.*.*.* */
-#endif
-};
-
-struct ip_set_req_iptree_create {
-	unsigned int timeout;
-};
-
-struct ip_set_req_iptree {
-	ip_set_ip_t ip;
-	unsigned int timeout;
-};
-
-#endif	/* __IP_SET_IPTREE_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_jhash.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_jhash.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_jhash.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_jhash.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,148 +0,0 @@
-#ifndef _LINUX_IPSET_JHASH_H
-#define _LINUX_IPSET_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 /* _LINUX_IPSET_JHASH_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_macipmap.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_macipmap.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_macipmap.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_macipmap.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,38 +0,0 @@
-#ifndef __IP_SET_MACIPMAP_H
-#define __IP_SET_MACIPMAP_H
-
-#include <linux/netfilter_ipv4/ip_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 ip_set_macipmap {
-	void *members;			/* the macipmap proper */
-	ip_set_ip_t first_ip;		/* host byte order, included in range */
-	ip_set_ip_t last_ip;		/* host byte order, included in range */
-	u_int32_t flags;
-};
-
-struct ip_set_req_macipmap_create {
-	ip_set_ip_t from;
-	ip_set_ip_t to;
-	u_int32_t flags;
-};
-
-struct ip_set_req_macipmap {
-	ip_set_ip_t ip;
-	unsigned char ethernet[ETH_ALEN];
-};
-
-struct ip_set_macip {
-	unsigned short flags;
-	unsigned char ethernet[ETH_ALEN];
-};
-
-#endif	/* __IP_SET_MACIPMAP_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_malloc.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_malloc.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_malloc.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_malloc.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,116 +0,0 @@
-#ifndef _IP_SET_MALLOC_H
-#define _IP_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 * ip_set_malloc(size_t bytes)
-{
-	if (bytes > max_malloc_size)
-		return vmalloc(bytes);
-	else
-		return kmalloc(bytes, GFP_KERNEL);
-}
-
-static inline void ip_set_free(void * data, size_t bytes)
-{
-	if (bytes > max_malloc_size)
-		vfree(data);
-	else
-		kfree(data);
-}
-
-struct harray {
-	size_t max_elements;
-	void *arrays[0];
-};
-
-static inline void * 
-harray_malloc(size_t hashsize, size_t typesize, int flags)
-{
-	struct harray *harray;
-	size_t max_elements, size, i, j;
-
-	if (!max_malloc_size)
-		init_max_malloc_size();
-
-	if (typesize > max_malloc_size)
-		return NULL;
-
-	max_elements = max_malloc_size/typesize;
-	size = hashsize/max_elements;
-	if (hashsize % max_elements)
-		size++;
-	
-	/* Last pointer signals end of arrays */
-	harray = kmalloc(sizeof(struct harray) + (size + 1) * sizeof(void *),
-			 flags);
-
-	if (!harray)
-		return NULL;
-	
-	for (i = 0; i < size - 1; i++) {
-		harray->arrays[i] = kmalloc(max_elements * typesize, flags);
-		if (!harray->arrays[i])
-			goto undo;
-		memset(harray->arrays[i], 0, max_elements * typesize);
-	}
-	harray->arrays[i] = kmalloc((hashsize - i * max_elements) * typesize, 
-				    flags);
-	if (!harray->arrays[i])
-		goto undo;
-	memset(harray->arrays[i], 0, (hashsize - i * max_elements) * typesize);
-
-	harray->max_elements = max_elements;
-	harray->arrays[size] = NULL;
-	
-	return (void *)harray;
-
-    undo:
-    	for (j = 0; j < i; j++) {
-    		kfree(harray->arrays[j]);
-    	}
-    	kfree(harray);
-    	return NULL;
-}
-
-static inline void harray_free(void *h)
-{
-	struct harray *harray = (struct harray *) h;
-	size_t i;
-	
-    	for (i = 0; harray->arrays[i] != NULL; i++)
-    		kfree(harray->arrays[i]);
-    	kfree(harray);
-}
-
-static inline void harray_flush(void *h, size_t hashsize, size_t typesize)
-{
-	struct harray *harray = (struct harray *) h;
-	size_t i;
-	
-    	for (i = 0; harray->arrays[i+1] != NULL; i++)
-		memset(harray->arrays[i], 0, harray->max_elements * typesize);
-	memset(harray->arrays[i], 0, 
-	       (hashsize - i * harray->max_elements) * typesize);
-}
-
-#define HARRAY_ELEM(h, type, which)				\
-({								\
-	struct harray *__h = (struct harray *)(h);		\
-	((type)((__h)->arrays[(which)/(__h)->max_elements])	\
-		+ (which)%(__h)->max_elements);			\
-})
-
-#endif				/* __KERNEL__ */
-
-#endif /*_IP_SET_MALLOC_H*/
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_nethash.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_nethash.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_nethash.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_nethash.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,54 +0,0 @@
-#ifndef __IP_SET_NETHASH_H
-#define __IP_SET_NETHASH_H
-
-#include <linux/netfilter_ipv4/ip_set.h>
-
-#define SETTYPE_NAME "nethash"
-#define MAX_RANGE 0x0000FFFF
-
-struct ip_set_nethash {
-	ip_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 ip_set_req_nethash_create {
-	uint32_t hashsize;
-	uint16_t probes;
-	uint16_t resize;
-};
-
-struct ip_set_req_nethash {
-	ip_set_ip_t ip;
-	unsigned char cidr;
-};
-
-static unsigned char shifts[] = {255, 253, 249, 241, 225, 193, 129, 1};
-
-static inline ip_set_ip_t 
-pack(ip_set_ip_t ip, unsigned char cidr)
-{
-	ip_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	/* __IP_SET_NETHASH_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_portmap.h linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_portmap.h
--- linux-2.6.15.3-ipset/include/linux/netfilter_ipv4/ip_set_portmap.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ip_set_portmap.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,25 +0,0 @@
-#ifndef __IP_SET_PORTMAP_H
-#define __IP_SET_PORTMAP_H
-
-#include <linux/netfilter_ipv4/ip_set.h>
-
-#define SETTYPE_NAME	"portmap"
-#define MAX_RANGE	0x0000FFFF
-#define INVALID_PORT	(MAX_RANGE + 1)
-
-struct ip_set_portmap {
-	void *members;			/* the portmap proper */
-	ip_set_ip_t first_port;		/* host byte order, included in range */
-	ip_set_ip_t last_port;		/* host byte order, included in range */
-};
-
-struct ip_set_req_portmap_create {
-	ip_set_ip_t from;
-	ip_set_ip_t to;
-};
-
-struct ip_set_req_portmap {
-	ip_set_ip_t port;
-};
-
-#endif /* __IP_SET_PORTMAP_H */
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/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-ipset/include/linux/netfilter_ipv4/ipt_set.h	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/include/linux/netfilter_ipv4/ipt_set.h	2006-03-13 13:18:31.000000000 +0100
@@ -1,11 +1,12 @@
 #ifndef _IPT_SET_H
 #define _IPT_SET_H
 
-#include <linux/netfilter_ipv4/ip_set.h>
+#include <linux/netfilter/nf_set.h>
 
 struct ipt_set_info {
-	ip_set_id_t index;
-	u_int32_t flags[IP_SET_MAX_BINDINGS + 1];
+	char name[NF_SET_MAXNAMELEN];
+	nf_set_id_t index;
+	u_int32_t flags[NF_SET_MAX_STORAGE + 1];
 };
 
 /* match info */
@@ -13,6 +14,7 @@
 	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;
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/Kconfig linux-2.6.15.3-nfset/net/ipv4/netfilter/Kconfig
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/Kconfig	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/Kconfig	2006-03-09 10:22:11.000000000 +0100
@@ -842,111 +842,22 @@
 	  Allows altering the ARP packet payload: source and destination
 	  hardware and network addresses.
 
-config IP_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
-	  ipset(8).
-
-	  To compile it as a module, choose M here.  If unsure, say N.
-
-config IP_NF_SET_MAX
-	int "Maximum number of IP sets"
-	default 256
-	range 2 65534
-	depends on IP_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 'ip_set' module.
-
-config IP_NF_SET_HASHSIZE
-	int "Hash size for bindings of IP sets"
-	default 1024
-	depends on IP_NF_SET
-	help
-	  You can define here default value of the hash size for
-	  bindings of IP sets.
-
-	  The value can be overriden by the 'hash_size' module
-	  parameter of the 'ip_set' module.
-
-config IP_NF_SET_IPMAP
-	tristate "ipmap set support"
-	depends on IP_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 IP_NF_SET_MACIPMAP
-	tristate "macipmap set support"
-	depends on IP_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 IP_NF_SET_PORTMAP
-	tristate "portmap set support"
-	depends on IP_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 IP_NF_SET_IPHASH
-	tristate "iphash set support"
-	depends on IP_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 IP_NF_SET_NETHASH
-	tristate "nethash set support"
-	depends on IP_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 IP_NF_SET_IPPORTHASH
-	tristate "ipporthash set support"
-	depends on IP_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 IP_NF_SET_IPTREE
-	tristate "iptree set support"
-	depends on IP_NF_SET
-	help
-	  This option adds the iptree set type support.
-
-	  To compile it as a module, choose M here.  If unsure, say N.
-
 config IP_NF_MATCH_SET
 	tristate "set match support"
-	depends on IP_NF_SET
+	depends on NF_SET
 	help
 	  Set matching matches against given IP sets.
-	  You need the ipset utility to create and set up the 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 IP_NF_SET
+	depends on NF_SET
 	help
 	  The SET target makes possible to add/delete entries
 	  in IP sets.
-	  You need the ipset utility to create and set up the 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.
 
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/Makefile linux-2.6.15.3-nfset/net/ipv4/netfilter/Makefile
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/Makefile	2006-03-09 13:45:53.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
@@ -64,7 +65,6 @@
 obj-$(CONFIG_IP_NF_MATCH_AH_ESP) += ipt_ah.o ipt_esp.o
 obj-$(CONFIG_IP_NF_MATCH_LENGTH) += ipt_length.o
 obj-$(CONFIG_IP_NF_MATCH_TTL) += ipt_ttl.o
-obj-$(CONFIG_IP_NF_MATCH_SET) += ipt_set.o
 obj-$(CONFIG_IP_NF_MATCH_STATE) += ipt_state.o
 obj-$(CONFIG_IP_NF_MATCH_CONNMARK) += ipt_connmark.o
 obj-$(CONFIG_IP_NF_MATCH_CONNTRACK) += ipt_conntrack.o
@@ -93,19 +93,9 @@
 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_SET) += ipt_SET.o
-
-# sets
-obj-$(CONFIG_IP_NF_SET) += ip_set.o
-obj-$(CONFIG_IP_NF_SET_IPMAP) += ip_set_ipmap.o
-obj-$(CONFIG_IP_NF_SET_PORTMAP) += ip_set_portmap.o
-obj-$(CONFIG_IP_NF_SET_MACIPMAP) += ip_set_macipmap.o
-obj-$(CONFIG_IP_NF_SET_IPHASH) += ip_set_iphash.o
-obj-$(CONFIG_IP_NF_SET_NETHASH) += ip_set_nethash.o
-obj-$(CONFIG_IP_NF_SET_IPPORTHASH) += ip_set_ipporthash.o
-obj-$(CONFIG_IP_NF_SET_IPTREE) += ip_set_iptree.o
 obj-$(CONFIG_IP_NF_TARGET_NFQUEUE) += ipt_NFQUEUE.o
 
 # generic ARP tables
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set.c	1970-01-01 01:00:00.000000000 +0100
@@ -1,1992 +0,0 @@
-/* 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 for IP set management */
-
-#include <linux/config.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/kmod.h>
-#include <linux/ip.h>
-#include <linux/skbuff.h>
-#include <linux/random.h>
-#include <linux/jhash.h>
-#include <linux/netfilter_ipv4/ip_tables.h>
-#include <linux/errno.h>
-#include <asm/uaccess.h>
-#include <asm/bitops.h>
-#include <asm/semaphore.h>
-#include <linux/spinlock.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_ipv4/ip_set.h>
-
-static struct list_head set_type_list;		/* all registered sets */
-static struct ip_set **ip_set_list;		/* all individual sets */
-static DEFINE_RWLOCK(ip_set_lock);		/* protects the lists and the hash */
-static DECLARE_MUTEX(ip_set_app_mutex);		/* serializes user access */
-static ip_set_id_t ip_set_max = CONFIG_IP_NF_SET_MAX;
-static ip_set_id_t ip_set_bindings_hash_size =  CONFIG_IP_NF_SET_HASHSIZE;
-static struct list_head *ip_set_hash;		/* hash of bindings */
-static unsigned int ip_set_hash_random;		/* random seed */
-
-/*
- * Sets are identified either by the index in ip_set_list or by id.
- * The id never changes and is used to find a key in the hash. 
- * The index may change by swapping and used at all other places 
- * (set/SET netfilter modules, binding value, etc.)
- *
- * Userspace requests are serialized by ip_set_mutex and sets can
- * be deleted only from userspace. Therefore ip_set_list locking 
- * must obey the following rules:
- *
- * - kernel requests: read and write locking mandatory
- * - user requests: read locking optional, write locking mandatory
- */
-
-static inline void
-__ip_set_get(ip_set_id_t index)
-{
-	atomic_inc(&ip_set_list[index]->ref);
-}
-
-static inline void
-__ip_set_put(ip_set_id_t index)
-{
-	atomic_dec(&ip_set_list[index]->ref);
-}
-
-/*
- * Binding routines
- */
-
-static inline int
-ip_hash_cmp(const struct ip_set_hash *set_hash,
-	    ip_set_id_t id, ip_set_ip_t ip)
-{
-	return set_hash->id == id && set_hash->ip == ip;
-}
-
-static ip_set_id_t
-ip_set_find_in_hash(ip_set_id_t id, ip_set_ip_t ip)
-{
-	u_int32_t key = jhash_2words(id, ip, ip_set_hash_random) 
-				% ip_set_bindings_hash_size;
-	struct ip_set_hash *set_hash;
-
-	ASSERT_READ_LOCK(&ip_set_lock);
-	IP_SET_ASSERT(ip_set_list[id]);
-	DP("set: %s, ip: %u.%u.%u.%u", ip_set_list[id]->name, HIPQUAD(ip));	
-	
-	set_hash = LIST_FIND(&ip_set_hash[key], ip_hash_cmp,
-			     struct ip_set_hash *, id, ip);
-	
-	DP("set: %s, ip: %u.%u.%u.%u, binding: %s", ip_set_list[id]->name, 
-	   HIPQUAD(ip),
-	   set_hash != NULL ? ip_set_list[set_hash->binding]->name : "");
-
-	return (set_hash != NULL ? set_hash->binding : IP_SET_INVALID_ID);
-}
-
-static inline void 
-__set_hash_del(struct ip_set_hash *set_hash)
-{
-	ASSERT_WRITE_LOCK(&ip_set_lock);
-	IP_SET_ASSERT(ip_set_list[set_hash->binding]);	
-
-	__ip_set_put(set_hash->binding);
-	list_del(&set_hash->list);
-	kfree(set_hash);
-}
-
-static int
-ip_set_hash_del(ip_set_id_t id, ip_set_ip_t ip)
-{
-	u_int32_t key = jhash_2words(id, ip, ip_set_hash_random)
-				% ip_set_bindings_hash_size;
-	struct ip_set_hash *set_hash;
-	
-	IP_SET_ASSERT(ip_set_list[id]);
-	DP("set: %s, ip: %u.%u.%u.%u", ip_set_list[id]->name, HIPQUAD(ip));	
-	write_lock_bh(&ip_set_lock);
-	set_hash = LIST_FIND(&ip_set_hash[key], ip_hash_cmp,
-			     struct ip_set_hash *, id, ip);
-	DP("set: %s, ip: %u.%u.%u.%u, binding: %s", ip_set_list[id]->name,
-	   HIPQUAD(ip),
-	   set_hash != NULL ? ip_set_list[set_hash->binding]->name : "");
-
-	if (set_hash != NULL)
-		__set_hash_del(set_hash);
-	write_unlock_bh(&ip_set_lock);
-	return 0;
-}
-
-static int 
-ip_set_hash_add(ip_set_id_t id, ip_set_ip_t ip, ip_set_id_t binding)
-{
-	u_int32_t key = jhash_2words(id, ip, ip_set_hash_random)
-				% ip_set_bindings_hash_size;
-	struct ip_set_hash *set_hash;
-	int ret = 0;
-	
-	IP_SET_ASSERT(ip_set_list[id]);
-	IP_SET_ASSERT(ip_set_list[binding]);
-	DP("set: %s, ip: %u.%u.%u.%u, binding: %s", ip_set_list[id]->name, 
-	   HIPQUAD(ip), ip_set_list[binding]->name);
-	write_lock_bh(&ip_set_lock);
-	set_hash = LIST_FIND(&ip_set_hash[key], ip_hash_cmp,
-			     struct ip_set_hash *, id, ip);
-	if (!set_hash) {
-		set_hash = kmalloc(sizeof(struct ip_set_hash), GFP_KERNEL);
-		if (!set_hash) {
-			ret = -ENOMEM;
-			goto unlock;
-		}
-		INIT_LIST_HEAD(&set_hash->list);
-		set_hash->id = id;
-		set_hash->ip = ip;
-		list_add(&ip_set_hash[key], &set_hash->list);
-	} else {
-		IP_SET_ASSERT(ip_set_list[set_hash->binding]);	
-		DP("overwrite binding: %s",
-		   ip_set_list[set_hash->binding]->name);
-		__ip_set_put(set_hash->binding);
-	}
-	set_hash->binding = binding;
-	__ip_set_get(set_hash->binding);
-    unlock:
-	write_unlock_bh(&ip_set_lock);
-	return ret;
-}
-
-#define FOREACH_HASH_DO(fn, args...) 						\
-({										\
-	ip_set_id_t __key;							\
-	struct ip_set_hash *__set_hash;						\
-										\
-	for (__key = 0; __key < ip_set_bindings_hash_size; __key++) {		\
-		list_for_each_entry(__set_hash, &ip_set_hash[__key], list)	\
-			fn(__set_hash , ## args);				\
-	}									\
-})
-
-#define FOREACH_HASH_RW_DO(fn, args...) 						\
-({										\
-	ip_set_id_t __key;							\
-	struct ip_set_hash *__set_hash, *__n;					\
-										\
-	ASSERT_WRITE_LOCK(&ip_set_lock);					\
-	for (__key = 0; __key < ip_set_bindings_hash_size; __key++) {		\
-		list_for_each_entry_safe(__set_hash, __n, &ip_set_hash[__key], list)\
-			fn(__set_hash , ## args);				\
-	}									\
-})
-
-/* Add, del and test set entries from kernel */
-
-#define follow_bindings(index, set, ip)					\
-((index = ip_set_find_in_hash((set)->id, ip)) != IP_SET_INVALID_ID	\
- || (index = (set)->binding) != IP_SET_INVALID_ID)
-
-int
-ip_set_testip_kernel(ip_set_id_t index,
-		     const struct sk_buff *skb,
-		     const u_int32_t *flags)
-{
-	struct ip_set *set;
-	ip_set_ip_t ip;
-	int res;
-	unsigned char i = 0;
-	
-	IP_SET_ASSERT(flags[i]);
-	read_lock_bh(&ip_set_lock);
-	do {
-		set = ip_set_list[index];
-		IP_SET_ASSERT(set);
-		DP("set %s, index %u", set->name, index);
-		read_lock_bh(&set->lock);
-		res = set->type->testip_kernel(set, skb, &ip, flags, i++);
-		read_unlock_bh(&set->lock);
-		i += !!(set->type->features & IPSET_DATA_DOUBLE);
-	} while (res > 0 
-		 && flags[i] 
-		 && follow_bindings(index, set, ip));
-	read_unlock_bh(&ip_set_lock);
-
-	return res;
-}
-
-void
-ip_set_addip_kernel(ip_set_id_t index,
-		    const struct sk_buff *skb,
-		    const u_int32_t *flags)
-{
-	struct ip_set *set;
-	ip_set_ip_t ip;
-	int res;
-	unsigned char i = 0;
-
-	IP_SET_ASSERT(flags[i]);
-   retry:
-	read_lock_bh(&ip_set_lock);
-	do {
-		set = ip_set_list[index];
-		IP_SET_ASSERT(set);
-		DP("set %s, index %u", set->name, index);
-		write_lock_bh(&set->lock);
-		res = set->type->addip_kernel(set, skb, &ip, flags, i++);
-		write_unlock_bh(&set->lock);
-		i += !!(set->type->features & IPSET_DATA_DOUBLE);
-	} while ((res == 0 || res == -EEXIST)
-		 && flags[i] 
-		 && follow_bindings(index, set, ip));
-	read_unlock_bh(&ip_set_lock);
-
-	if (res == -EAGAIN
-	    && set->type->retry
-	    && (res = set->type->retry(set)) == 0)
-	    	goto retry;
-}
-
-void
-ip_set_delip_kernel(ip_set_id_t index,
-		    const struct sk_buff *skb,
-		    const u_int32_t *flags)
-{
-	struct ip_set *set;
-	ip_set_ip_t ip;
-	int res;
-	unsigned char i = 0;
-
-	IP_SET_ASSERT(flags[i]);
-	read_lock_bh(&ip_set_lock);
-	do {
-		set = ip_set_list[index];
-		IP_SET_ASSERT(set);
-		DP("set %s, index %u", set->name, index);
-		write_lock_bh(&set->lock);
-		res = set->type->delip_kernel(set, skb, &ip, flags, i++);
-		write_unlock_bh(&set->lock);
-		i += !!(set->type->features & IPSET_DATA_DOUBLE);
-	} while ((res == 0 || res == -EEXIST)
-		 && flags[i] 
-		 && follow_bindings(index, set, ip));
-	read_unlock_bh(&ip_set_lock);
-}
-
-/* Register and deregister settype */
-
-static inline int
-set_type_equal(const struct ip_set_type *set_type, const char *str2)
-{
-	return !strncmp(set_type->typename, str2, IP_SET_MAXNAMELEN - 1);
-}
-
-static inline struct ip_set_type *
-find_set_type(const char *name)
-{
-	return LIST_FIND(&set_type_list,
-			 set_type_equal,
-			 struct ip_set_type *,
-			 name);
-}
-
-int 
-ip_set_register_set_type(struct ip_set_type *set_type)
-{
-	int ret = 0;
-	
-	if (set_type->protocol_version != IP_SET_PROTOCOL_VERSION) {
-		ip_set_printk("'%s' uses wrong protocol version %u (want %u)",
-			      set_type->typename,
-			      set_type->protocol_version,
-			      IP_SET_PROTOCOL_VERSION);
-		return -EINVAL;
-	}
-
-	write_lock_bh(&ip_set_lock);
-	if (find_set_type(set_type->typename)) {
-		/* Duplicate! */
-		ip_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(&ip_set_lock);
-	return ret;
-}
-
-void
-ip_set_unregister_set_type(struct ip_set_type *set_type)
-{
-	write_lock_bh(&ip_set_lock);
-	if (!find_set_type(set_type->typename)) {
-		ip_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(&ip_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 ip_set_put().
- */
-ip_set_id_t
-ip_set_get_byname(const char *name)
-{
-	ip_set_id_t i, index = IP_SET_INVALID_ID;
-	
-	down(&ip_set_app_mutex);
-	for (i = 0; i < ip_set_max; i++) {
-		if (ip_set_list[i] != NULL
-		    && strcmp(ip_set_list[i]->name, name) == 0) {
-			__ip_set_get(i);
-			index = i;
-			break;
-		}
-	}
-	up(&ip_set_app_mutex);
-	return index;
-}
-
-/*
- * Find set by index, reference it once. The reference makes sure the
- * thing pointed to, does not go away under our feet. Drop the reference
- * later, using ip_set_put().
- */
-ip_set_id_t
-ip_set_get_byindex(ip_set_id_t index)
-{
-	down(&ip_set_app_mutex);
-
-	if (index >= ip_set_max)
-		return IP_SET_INVALID_ID;
-	
-	if (ip_set_list[index])
-		__ip_set_get(index);
-	else
-		index = IP_SET_INVALID_ID;
-		
-	up(&ip_set_app_mutex);
-	return index;
-}
-
-/*
- * If the given set pointer points to a valid set, decrement
- * reference count by 1. The caller shall not assume the index
- * to be valid, after calling this function.
- */
-void ip_set_put(ip_set_id_t index)
-{
-	down(&ip_set_app_mutex);
-	if (ip_set_list[index])
-		__ip_set_put(index);
-	up(&ip_set_app_mutex);
-}
-
-/* Find a set by name or index */
-static ip_set_id_t
-ip_set_find_byname(const char *name)
-{
-	ip_set_id_t i, index = IP_SET_INVALID_ID;
-	
-	for (i = 0; i < ip_set_max; i++) {
-		if (ip_set_list[i] != NULL
-		    && strcmp(ip_set_list[i]->name, name) == 0) {
-			index = i;
-			break;
-		}
-	}
-	return index;
-}
-
-static ip_set_id_t
-ip_set_find_byindex(ip_set_id_t index)
-{
-	if (index >= ip_set_max || ip_set_list[index] == NULL)
-		index = IP_SET_INVALID_ID;
-	
-	return index;
-}
-
-/*
- * Add, del, test, bind and unbind
- */
-
-static inline int
-__ip_set_testip(struct ip_set *set,
-	        const void *data,
-	        size_t size,
-	        ip_set_ip_t *ip)
-{
-	int res;
-
-	read_lock_bh(&set->lock);
-	res = set->type->testip(set, data, size, ip);
-	read_unlock_bh(&set->lock);
-
-	return res;
-}
-
-static int
-__ip_set_addip(ip_set_id_t index,
-	       const void *data,
-	       size_t size)
-{
-	struct ip_set *set = ip_set_list[index];
-	ip_set_ip_t ip;
-	int res;
-	
-	IP_SET_ASSERT(set);
-	do {
-		write_lock_bh(&set->lock);
-		res = set->type->addip(set, data, size, &ip);
-		write_unlock_bh(&set->lock);
-	} while (res == -EAGAIN
-		 && set->type->retry
-		 && (res = set->type->retry(set)) == 0);
-
-	return res;
-}
-
-static int
-ip_set_addip(ip_set_id_t index,
-	     const void *data,
-	     size_t size)
-{
-
-	return __ip_set_addip(index,
-			      data + sizeof(struct ip_set_req_adt),
-			      size - sizeof(struct ip_set_req_adt));
-}
-
-static int
-ip_set_delip(ip_set_id_t index,
-	     const void *data,
-	     size_t size)
-{
-	struct ip_set *set = ip_set_list[index];
-	ip_set_ip_t ip;
-	int res;
-	
-	IP_SET_ASSERT(set);
-	write_lock_bh(&set->lock);
-	res = set->type->delip(set,
-			       data + sizeof(struct ip_set_req_adt),
-			       size - sizeof(struct ip_set_req_adt),
-			       &ip);
-	write_unlock_bh(&set->lock);
-
-	return res;
-}
-
-static int
-ip_set_testip(ip_set_id_t index,
-	      const void *data,
-	      size_t size)
-{
-	struct ip_set *set = ip_set_list[index];
-	ip_set_ip_t ip;
-	int res;
-
-	IP_SET_ASSERT(set);
-	res = __ip_set_testip(set,
-			      data + sizeof(struct ip_set_req_adt),
-			      size - sizeof(struct ip_set_req_adt),
-			      &ip);
-
-	return (res > 0 ? -EEXIST : res);
-}
-
-static int
-ip_set_bindip(ip_set_id_t index,
-	      const void *data,
-	      size_t size)
-{
-	struct ip_set *set = ip_set_list[index];
-	struct ip_set_req_bind *req_bind;
-	ip_set_id_t binding;
-	ip_set_ip_t ip;
-	int res;
-
-	IP_SET_ASSERT(set);
-	if (size < sizeof(struct ip_set_req_bind))
-		return -EINVAL;
-		
-	req_bind = (struct ip_set_req_bind *) data;
-	req_bind->binding[IP_SET_MAXNAMELEN - 1] = '\0';
-
-	if (strcmp(req_bind->binding, IPSET_TOKEN_DEFAULT) == 0) {
-		/* Default binding of a set */
-		char *binding_name;
-		
-		if (size != sizeof(struct ip_set_req_bind) + IP_SET_MAXNAMELEN)
-			return -EINVAL;
-
-		binding_name = (char *)(data + sizeof(struct ip_set_req_bind));	
-		binding_name[IP_SET_MAXNAMELEN - 1] = '\0';
-
-		binding = ip_set_find_byname(binding_name);
-		if (binding == IP_SET_INVALID_ID)
-			return -ENOENT;
-
-		write_lock_bh(&ip_set_lock);
-		/* Sets as binding values are referenced */
-		if (set->binding != IP_SET_INVALID_ID)
-			__ip_set_put(set->binding);
-		set->binding = binding;
-		__ip_set_get(set->binding);
-		write_unlock_bh(&ip_set_lock);
-
-		return 0;
-	}
-	binding = ip_set_find_byname(req_bind->binding);
-	if (binding == IP_SET_INVALID_ID)
-		return -ENOENT;
-
-	res = __ip_set_testip(set,
-			      data + sizeof(struct ip_set_req_bind),
-			      size - sizeof(struct ip_set_req_bind),
-			      &ip);
-	DP("set %s, ip: %u.%u.%u.%u, binding %s",
-	   set->name, HIPQUAD(ip), ip_set_list[binding]->name);
-	
-	if (res >= 0)
-		res = ip_set_hash_add(set->id, ip, binding);
-
-	return res;
-}
-
-#define FOREACH_SET_DO(fn, args...) 				\
-({								\
-	ip_set_id_t __i;					\
-	struct ip_set *__set;					\
-								\
-	for (__i = 0; __i < ip_set_max; __i++) {		\
-		__set = ip_set_list[__i];			\
-		if (__set != NULL)				\
-			fn(__set , ##args);			\
-	}							\
-})
-
-static inline void
-__set_hash_del_byid(struct ip_set_hash *set_hash, ip_set_id_t id)
-{
-	if (set_hash->id == id)
-		__set_hash_del(set_hash);
-}
-
-static inline void
-__unbind_default(struct ip_set *set)
-{
-	if (set->binding != IP_SET_INVALID_ID) {
-		/* Sets as binding values are referenced */
-		__ip_set_put(set->binding);
-		set->binding = IP_SET_INVALID_ID;
-	}
-}
-
-static int
-ip_set_unbindip(ip_set_id_t index,
-	        const void *data,
-	        size_t size)
-{
-	struct ip_set *set;
-	struct ip_set_req_bind *req_bind;
-	ip_set_ip_t ip;
-	int res;
-
-	DP("");
-	if (size < sizeof(struct ip_set_req_bind))
-		return -EINVAL;
-		
-	req_bind = (struct ip_set_req_bind *) data;
-	req_bind->binding[IP_SET_MAXNAMELEN - 1] = '\0';
-	
-	DP("%u %s", index, req_bind->binding);
-	if (index == IP_SET_INVALID_ID) {
-		/* unbind :all: */
-		if (strcmp(req_bind->binding, IPSET_TOKEN_DEFAULT) == 0) {
-			/* Default binding of sets */
-			write_lock_bh(&ip_set_lock);
-			FOREACH_SET_DO(__unbind_default);
-			write_unlock_bh(&ip_set_lock);
-			return 0;
-		} else if (strcmp(req_bind->binding, IPSET_TOKEN_ALL) == 0) {
-			/* Flush all bindings of all sets*/
-			write_lock_bh(&ip_set_lock);
-			FOREACH_HASH_RW_DO(__set_hash_del);
-			write_unlock_bh(&ip_set_lock);
-			return 0;
-		}
-		DP("unreachable reached!");
-		return -EINVAL;
-	}
-	
-	set = ip_set_list[index];
-	IP_SET_ASSERT(set);
-	if (strcmp(req_bind->binding, IPSET_TOKEN_DEFAULT) == 0) {
-		/* Default binding of set */
-		ip_set_id_t binding = ip_set_find_byindex(set->binding);
-
-		if (binding == IP_SET_INVALID_ID)
-			return -ENOENT;
-			
-		write_lock_bh(&ip_set_lock);
-		/* Sets in hash values are referenced */
-		__ip_set_put(set->binding);
-		set->binding = IP_SET_INVALID_ID;
-		write_unlock_bh(&ip_set_lock);
-
-		return 0;
-	} else if (strcmp(req_bind->binding, IPSET_TOKEN_ALL) == 0) {
-		/* Flush all bindings */
-
-		write_lock_bh(&ip_set_lock);
-		FOREACH_HASH_RW_DO(__set_hash_del_byid, set->id);
-		write_unlock_bh(&ip_set_lock);
-		return 0;
-	}
-	
-	res = __ip_set_testip(set,
-			      data + sizeof(struct ip_set_req_bind),
-			      size - sizeof(struct ip_set_req_bind),
-			      &ip);
-
-	DP("set %s, ip: %u.%u.%u.%u", set->name, HIPQUAD(ip));
-	if (res >= 0)
-		res = ip_set_hash_del(set->id, ip);
-
-	return res;
-}
-
-static int
-ip_set_testbind(ip_set_id_t index,
-	        const void *data,
-	        size_t size)
-{
-	struct ip_set *set = ip_set_list[index];
-	struct ip_set_req_bind *req_bind;
-	ip_set_id_t binding;
-	ip_set_ip_t ip;
-	int res;
-
-	IP_SET_ASSERT(set);
-	if (size < sizeof(struct ip_set_req_bind))
-		return -EINVAL;
-		
-	req_bind = (struct ip_set_req_bind *) data;
-	req_bind->binding[IP_SET_MAXNAMELEN - 1] = '\0';
-
-	if (strcmp(req_bind->binding, IPSET_TOKEN_DEFAULT) == 0) {
-		/* Default binding of set */
-		char *binding_name;
-		
-		if (size != sizeof(struct ip_set_req_bind) + IP_SET_MAXNAMELEN)
-			return -EINVAL;
-
-		binding_name = (char *)(data + sizeof(struct ip_set_req_bind));	
-		binding_name[IP_SET_MAXNAMELEN - 1] = '\0';
-
-		binding = ip_set_find_byname(binding_name);
-		if (binding == IP_SET_INVALID_ID)
-			return -ENOENT;
-		
-		res = (set->binding == binding) ? -EEXIST : 0;
-
-		return res;
-	}
-	binding = ip_set_find_byname(req_bind->binding);
-	if (binding == IP_SET_INVALID_ID)
-		return -ENOENT;
-		
-	
-	res = __ip_set_testip(set,
-			      data + sizeof(struct ip_set_req_bind),
-			      size - sizeof(struct ip_set_req_bind),
-			      &ip);
-	DP("set %s, ip: %u.%u.%u.%u, binding %s",
-	   set->name, HIPQUAD(ip), ip_set_list[binding]->name);
-	   
-	if (res >= 0)
-		res = (ip_set_find_in_hash(set->id, ip) == binding)
-			? -EEXIST : 0;
-
-	return res;
-}
-
-static struct ip_set_type *
-find_set_type_rlock(const char *typename)
-{
-	struct ip_set_type *type;
-	
-	read_lock_bh(&ip_set_lock);
-	type = find_set_type(typename);
-	if (type == NULL)
-		read_unlock_bh(&ip_set_lock);
-
-	return type;
-}
-
-static int
-find_free_id(const char *name,
-	     ip_set_id_t *index,
-	     ip_set_id_t *id)
-{
-	ip_set_id_t i;
-
-	*id = IP_SET_INVALID_ID;
-	for (i = 0;  i < ip_set_max; i++) {
-		if (ip_set_list[i] == NULL) {
-			if (*id == IP_SET_INVALID_ID)
-				*id = *index = i;
-		} else if (strcmp(name, ip_set_list[i]->name) == 0)
-			/* Name clash */
-			return -EEXIST;
-	}
-	if (*id == IP_SET_INVALID_ID)
-		/* No free slot remained */
-		return -ERANGE;
-	/* Check that index is usable as id (swapping) */
-    check:	
-	for (i = 0;  i < ip_set_max; i++) {
-		if (ip_set_list[i] != NULL
-		    && ip_set_list[i]->id == *id) {
-		    *id = i;
-		    goto check;
-		}
-	}
-	return 0;
-}
-
-/*
- * Create a set
- */
-static int
-ip_set_create(const char *name,
-	      const char *typename,
-	      ip_set_id_t restore,
-	      const void *data,
-	      size_t size)
-{
-	struct ip_set *set;
-	ip_set_id_t index, id;
-	int res = 0;
-
-	DP("setname: %s, typename: %s, id: %u", name, typename, restore);
-	/*
-	 * First, and without any locks, allocate and initialize
-	 * a normal base set structure.
-	 */
-	set = kmalloc(sizeof(struct ip_set), GFP_KERNEL);
-	if (!set)
-		return -ENOMEM;
-	set->lock = RW_LOCK_UNLOCKED;
-	strncpy(set->name, name, IP_SET_MAXNAMELEN);
-	set->binding = IP_SET_INVALID_ID;
-	atomic_set(&set->ref, 0);
-
-	/*
-	 * Next, take the &ip_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 &ip_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[IP_SET_MAXNAMELEN + strlen("ip_set_") + 1];
-		strcpy(modulename, "ip_set_");
-		strcat(modulename, typename);
-		DP("try to load %s", modulename);
-		request_module(modulename);
-		set->type = find_set_type_rlock(typename);
-	}
-	if (set->type == NULL) {
-		ip_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(&ip_set_lock);
-		res = -EFAULT;
-		goto out;
-	}
-	read_unlock_bh(&ip_set_lock);
-
-	/*
-	 * Without holding any locks, create private part.
-	 */
-	res = set->type->create(set, data, size);
-	if (res != 0)
-		goto put_out;
-
-	/* BTW, res==0 here. */
-
-	/*
-	 * Here, we have a valid, constructed set. &ip_set_lock again,
-	 * find free id/index and check that it is not already in 
-	 * ip_set_list.
-	 */
-	write_lock_bh(&ip_set_lock);
-	if ((res = find_free_id(set->name, &index, &id)) != 0) {
-		DP("no free id!");
-		goto cleanup;
-	}
-
-	/* Make sure restore gets the same index */
-	if (restore != IP_SET_INVALID_ID && index != restore) {
-		DP("Can't restore, sets are screwed up");
-		res = -ERANGE;
-		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;
-	ip_set_list[index] = set;
-	write_unlock_bh(&ip_set_lock);
-	return res;
-	
-    cleanup:
-	write_unlock_bh(&ip_set_lock);
-	set->type->destroy(set);
-    put_out:
-	module_put(set->type->me);
-    out:
-	kfree(set);
-	return res;
-}
-
-/*
- * Destroy a given existing set
- */
-static void
-ip_set_destroy_set(ip_set_id_t index)
-{
-	struct ip_set *set = ip_set_list[index];
-
-	IP_SET_ASSERT(set);
-	DP("set: %s",  set->name);
-	write_lock_bh(&ip_set_lock);
-	FOREACH_HASH_RW_DO(__set_hash_del_byid, set->id);
-	if (set->binding != IP_SET_INVALID_ID)
-		__ip_set_put(set->binding);
-	ip_set_list[index] = NULL;
-	write_unlock_bh(&ip_set_lock);
-
-	/* Must call it without holding any lock */
-	set->type->destroy(set);
-	module_put(set->type->me);
-	kfree(set);
-}
-
-/*
- * Destroy a set - or all sets
- * Sets must not be referenced/used.
- */
-static int
-ip_set_destroy(ip_set_id_t index)
-{
-	ip_set_id_t i;
-
-	/* ref modification always protected by the mutex */
-	if (index != IP_SET_INVALID_ID) {
-		if (atomic_read(&ip_set_list[index]->ref))
-			return -EBUSY;
-		ip_set_destroy_set(index);
-	} else {
-		for (i = 0; i < ip_set_max; i++) {
-			if (ip_set_list[i] != NULL 
-			    && (atomic_read(&ip_set_list[i]->ref)))
-			    	return -EBUSY;
-		}
-
-		for (i = 0; i < ip_set_max; i++) {
-			if (ip_set_list[i] != NULL)
-				ip_set_destroy_set(i);
-		}
-	}
-	return 0;
-}
-
-static void
-ip_set_flush_set(struct ip_set *set)
-{
-	DP("set: %s %u",  set->name, set->id);
-
-	write_lock_bh(&set->lock);
-	set->type->flush(set);
-	write_unlock_bh(&set->lock);
-}
-
-/* 
- * Flush data in a set - or in all sets
- */
-static int
-ip_set_flush(ip_set_id_t index)
-{
-	if (index != IP_SET_INVALID_ID) {
-		IP_SET_ASSERT(ip_set_list[index]);
-		ip_set_flush_set(ip_set_list[index]);
-	} else
-		FOREACH_SET_DO(ip_set_flush_set);
-
-	return 0;
-}
-
-/* Rename a set */
-static int
-ip_set_rename(ip_set_id_t index, const char *name)
-{
-	struct ip_set *set = ip_set_list[index];
-	ip_set_id_t i;
-	int res = 0;
-
-	DP("set: %s to %s",  set->name, name);
-	write_lock_bh(&ip_set_lock);
-	for (i = 0; i < ip_set_max; i++) {
-		if (ip_set_list[i] != NULL
-		    && strncmp(ip_set_list[i]->name, 
-			       name,
-			       IP_SET_MAXNAMELEN - 1) == 0) {
-			res = -EEXIST;
-			goto unlock;
-		}
-	}
-	strncpy(set->name, name, IP_SET_MAXNAMELEN);
-    unlock:
-	write_unlock_bh(&ip_set_lock);
-	return res;
-}
-
-/*
- * Swap two sets so that name/index points to the other.
- * References are also swapped.
- */
-static int
-ip_set_swap(ip_set_id_t from_index, ip_set_id_t to_index)
-{
-	struct ip_set *from = ip_set_list[from_index];
-	struct ip_set *to = ip_set_list[to_index];
-	char from_name[IP_SET_MAXNAMELEN];
-	u_int32_t from_ref;
-
-	DP("set: %s to %s",  from->name, to->name);
-	/* Features must not change. Artifical restriction. */
-	if (from->type->features != to->type->features)
-		return -ENOEXEC;
-
-	/* No magic here: ref munging protected by the mutex */	
-	write_lock_bh(&ip_set_lock);
-	strncpy(from_name, from->name, IP_SET_MAXNAMELEN);
-	from_ref = atomic_read(&from->ref);
-
-	strncpy(from->name, to->name, IP_SET_MAXNAMELEN);
-	atomic_set(&from->ref, atomic_read(&to->ref));
-	strncpy(to->name, from_name, IP_SET_MAXNAMELEN);
-	atomic_set(&to->ref, from_ref);
-	
-	ip_set_list[from_index] = to;
-	ip_set_list[to_index] = from;
-	
-	write_unlock_bh(&ip_set_lock);
-	return 0;
-}
-
-/*
- * List set data
- */
-
-static inline void
-__set_hash_bindings_size_list(struct ip_set_hash *set_hash,
-			      ip_set_id_t id, size_t *size)
-{
-	if (set_hash->id == id)
-		*size += sizeof(struct ip_set_hash_list);
-}
-
-static inline void
-__set_hash_bindings_size_save(struct ip_set_hash *set_hash,
-			      ip_set_id_t id, size_t *size)
-{
-	if (set_hash->id == id)
-		*size += sizeof(struct ip_set_hash_save);
-}
-
-static inline void
-__set_hash_bindings(struct ip_set_hash *set_hash,
-		    ip_set_id_t id, void *data, int *used)
-{
-	if (set_hash->id == id) {
-		struct ip_set_hash_list *hash_list = 
-			(struct ip_set_hash_list *)(data + *used);
-
-		hash_list->ip = set_hash->ip;
-		hash_list->binding = set_hash->binding;
-		*used += sizeof(struct ip_set_hash_list);
-	}
-}
-
-static int ip_set_list_set(ip_set_id_t index,
-			   void *data,
-			   int *used,
-			   int len)
-{
-	struct ip_set *set = ip_set_list[index];
-	struct ip_set_list *set_list;
-
-	/* Pointer to our header */
-	set_list = (struct ip_set_list *) (data + *used);
-
-	DP("set: %s, used: %d %p %p", set->name, *used, data, data + *used);
-
-	/* Get and ensure header size */
-	if (*used + sizeof(struct ip_set_list) > len)
-		goto not_enough_mem;
-	*used += sizeof(struct ip_set_list);
-
-	read_lock_bh(&set->lock);
-	/* Get and ensure set specific header size */
-	set_list->header_size = set->type->header_size;
-	if (*used + set_list->header_size > len)
-		goto unlock_set;
-
-	/* Fill in the header */
-	set_list->index = index;
-	set_list->binding = set->binding;
-	set_list->ref = atomic_read(&set->ref);
-
-	/* Fill in set spefific header data */
-	set->type->list_header(set, data + *used);
-	*used += set_list->header_size;
-
-	/* Get and ensure set specific members size */
-	set_list->members_size = set->type->list_members_size(set);
-	if (*used + set_list->members_size > len)
-		goto unlock_set;
-
-	/* Fill in set spefific members data */
-	set->type->list_members(set, data + *used);
-	*used += set_list->members_size;
-	read_unlock_bh(&set->lock);
-
-	/* Bindings */
-
-	/* Get and ensure set specific bindings size */
-	set_list->bindings_size = 0;
-	FOREACH_HASH_DO(__set_hash_bindings_size_list,
-			set->id, &set_list->bindings_size);
-	if (*used + set_list->bindings_size > len)
-		goto not_enough_mem;
-
-	/* Fill in set spefific bindings data */
-	FOREACH_HASH_DO(__set_hash_bindings, set->id, data, used);
-	
-	return 0;
-
-    unlock_set:
-	read_unlock_bh(&set->lock);
-    not_enough_mem:
-	DP("not enough mem, try again");
-	return -EAGAIN;
-}
-
-/*
- * Save sets
- */
-static int ip_set_save_set(ip_set_id_t index,
-			   void *data,
-			   int *used,
-			   int len)
-{
-	struct ip_set *set;
-	struct ip_set_save *set_save;
-
-	/* Pointer to our header */
-	set_save = (struct ip_set_save *) (data + *used);
-
-	/* Get and ensure header size */
-	if (*used + sizeof(struct ip_set_save) > len)
-		goto not_enough_mem;
-	*used += sizeof(struct ip_set_save);
-
-	set = ip_set_list[index];
-	DP("set: %s, used: %u(%u) %p %p", set->name, *used, len, 
-	   data, data + *used);
-
-	read_lock_bh(&set->lock);
-	/* Get and ensure set specific header size */
-	set_save->header_size = set->type->header_size;
-	if (*used + set_save->header_size > len)
-		goto unlock_set;
-
-	/* Fill in the header */
-	set_save->index = index;
-	set_save->binding = set->binding;
-
-	/* Fill in set spefific header data */
-	set->type->list_header(set, data + *used);
-	*used += set_save->header_size;
-
-	DP("set header filled: %s, used: %u %p %p", set->name, *used,
-	   data, data + *used);
-	/* Get and ensure set specific members size */
-	set_save->members_size = set->type->list_members_size(set);
-	if (*used + set_save->members_size > len)
-		goto unlock_set;
-
-	/* Fill in set spefific members data */
-	set->type->list_members(set, data + *used);
-	*used += set_save->members_size;
-	read_unlock_bh(&set->lock);
-	DP("set members filled: %s, used: %u %p %p", set->name, *used,
-	   data, data + *used);
-	return 0;
-
-    unlock_set:
-	read_unlock_bh(&set->lock);
-    not_enough_mem:
-	DP("not enough mem, try again");
-	return -EAGAIN;
-}
-
-static inline void
-__set_hash_save_bindings(struct ip_set_hash *set_hash,
-			 ip_set_id_t id,
-			 void *data,
-			 int *used,
-			 int len,
-			 int *res)
-{
-	if (*res == 0
-	    && (id == IP_SET_INVALID_ID || set_hash->id == id)) {
-		struct ip_set_hash_save *hash_save = 
-			(struct ip_set_hash_save *)(data + *used);
-		/* Ensure bindings size */
-		if (*used + sizeof(struct ip_set_hash_save) > len) {
-			*res = -ENOMEM;
-			return;
-		}
-		hash_save->id = set_hash->id;
-		hash_save->ip = set_hash->ip;
-		hash_save->binding = set_hash->binding;
-		*used += sizeof(struct ip_set_hash_save);
-	}
-}
-
-static int ip_set_save_bindings(ip_set_id_t index,
-			   	void *data,
-			   	int *used,
-			   	int len)
-{
-	int res = 0;
-	struct ip_set_save *set_save;
-
-	DP("used %u, len %u", *used, len);
-	/* Get and ensure header size */
-	if (*used + sizeof(struct ip_set_save) > len)
-		return -ENOMEM;
-
-	/* Marker */
-	set_save = (struct ip_set_save *) (data + *used);
-	set_save->index = IP_SET_INVALID_ID;
-	*used += sizeof(struct ip_set_save);
-
-	DP("marker added used %u, len %u", *used, len);
-	/* Fill in bindings data */
-	if (index != IP_SET_INVALID_ID)
-		/* Sets are identified by id in hash */
-		index = ip_set_list[index]->id;
-	FOREACH_HASH_DO(__set_hash_save_bindings, index, data, used, len, &res);
-
-	return res;	
-}
-
-/*
- * Restore sets
- */
-static int ip_set_restore(void *data,
-			  int len)
-{
-	int res = 0;
-	int line = 0, used = 0, members_size;
-	struct ip_set *set;
-	struct ip_set_hash_save *hash_save;
-	struct ip_set_restore *set_restore;
-	ip_set_id_t index;
-
-	/* Loop to restore sets */
-	while (1) {
-		line++;
-		
-		DP("%u %u %u", used, sizeof(struct ip_set_restore), len);
-		/* Get and ensure header size */
-		if (used + sizeof(struct ip_set_restore) > len)
-			return line;
-		set_restore = (struct ip_set_restore *) (data + used);
-		used += sizeof(struct ip_set_restore);
-
-		/* Ensure data size */
-		if (used 
-		    + set_restore->header_size 
-		    + set_restore->members_size > len)
-			return line;
-
-		/* Check marker */
-		if (set_restore->index == IP_SET_INVALID_ID) {
-			line--;
-			goto bindings;
-		}
-		
-		/* Try to create the set */
-		DP("restore %s %s", set_restore->name, set_restore->typename);
-		res = ip_set_create(set_restore->name,
-				    set_restore->typename,
-				    set_restore->index,
-				    data + used,
-				    set_restore->header_size);
-		
-		if (res != 0)
-			return line;
-		used += set_restore->header_size;
-
-		index = ip_set_find_byindex(set_restore->index);
-		DP("index %u, restore_index %u", index, set_restore->index);
-		if (index != set_restore->index)
-			return line;
-		/* Try to restore members data */
-		set = ip_set_list[index];
-		members_size = 0;
-		DP("members_size %u reqsize %u",
-		   set_restore->members_size, set->type->reqsize);
-		while (members_size + set->type->reqsize <=
-		       set_restore->members_size) {
-			line++;
-		       	DP("members: %u, line %u", members_size, line);
-			res = __ip_set_addip(index,
-					   data + used + members_size,
-					   set->type->reqsize);
-			if (!(res == 0 || res == -EEXIST)) 
-				return line;
-			members_size += set->type->reqsize;
-		}
-
-		DP("members_size %u  %u",
-		   set_restore->members_size, members_size);
-		if (members_size != set_restore->members_size)
-			return line++;
-		used += set_restore->members_size;		
-	}
-	
-   bindings:
-   	/* Loop to restore bindings */
-   	while (used < len) {
-		line++;
-
-		DP("restore binding, line %u", line);		
-		/* Get and ensure size */
-		if (used + sizeof(struct ip_set_hash_save) > len)
-			return line;
-		hash_save = (struct ip_set_hash_save *) (data + used);
-		used += sizeof(struct ip_set_hash_save);
-		
-		/* hash_save->id is used to store the index */
-		index = ip_set_find_byindex(hash_save->id);
-		DP("restore binding index %u, id %u, %u -> %u",
-		   index, hash_save->id, hash_save->ip, hash_save->binding);		
-		if (index != hash_save->id)
-			return line;
-			
-		set = ip_set_list[hash_save->id];
-		/* Null valued IP means default binding */
-		if (hash_save->ip)
-			res = ip_set_hash_add(set->id, 
-					      hash_save->ip,
-					      hash_save->binding);
-		else {
-			IP_SET_ASSERT(set->binding == IP_SET_INVALID_ID);
-			write_lock_bh(&ip_set_lock);
-			set->binding = hash_save->binding;
-			__ip_set_get(set->binding);
-			write_unlock_bh(&ip_set_lock);
-			DP("default binding: %u", set->binding);
-		}
-		if (res != 0)
-			return line;
-   	}
-   	if (used != len)
-   		return line;
-   	
-	return 0;	
-}
-
-static int
-ip_set_sockfn_set(struct sock *sk, int optval, void *user, unsigned int len)
-{
-	void *data;
-	int res = 0;		/* Assume OK */
-	unsigned *op;
-	struct ip_set_req_adt *req_adt;
-	ip_set_id_t index = IP_SET_INVALID_ID;
-	int (*adtfn)(ip_set_id_t index,
-		     const void *data, size_t size);
-	struct fn_table {
-		int (*fn)(ip_set_id_t index,
-			  const void *data, size_t size);
-	} adtfn_table[] =
-	{ { ip_set_addip }, { ip_set_delip }, { ip_set_testip},
-	  { ip_set_bindip}, { ip_set_unbindip }, { ip_set_testbind },
-	};
-
-	DP("optval=%d, user=%p, len=%d", optval, user, len);
-	if (!capable(CAP_NET_ADMIN))
-		return -EPERM;
-	if (optval != SO_IP_SET)
-		return -EBADF;
-	if (len <= sizeof(unsigned)) {
-		ip_set_printk("short userdata (want >%zu, got %u)",
-			      sizeof(unsigned), len);
-		return -EINVAL;
-	}
-	data = vmalloc(len);
-	if (!data) {
-		DP("out of mem for %u bytes", len);
-		return -ENOMEM;
-	}
-	if (copy_from_user(data, user, len) != 0) {
-		res = -EFAULT;
-		goto done;
-	}
-	if (down_interruptible(&ip_set_app_mutex)) {
-		res = -EINTR;
-		goto done;
-	}
-
-	op = (unsigned *)data;
-	DP("op=%x", *op);
-	
-	if (*op < IP_SET_OP_VERSION) {
-		/* Check the version at the beginning of operations */
-		struct ip_set_req_version *req_version =
-			(struct ip_set_req_version *) data;
-		if (req_version->version != IP_SET_PROTOCOL_VERSION) {
-			res = -EPROTO;
-			goto done;
-		}
-	}
-
-	switch (*op) {
-	case IP_SET_OP_CREATE:{
-		struct ip_set_req_create *req_create
-			= (struct ip_set_req_create *) data;
-		
-		if (len <= sizeof(struct ip_set_req_create)) {
-			ip_set_printk("short CREATE data (want >%zu, got %u)",
-				      sizeof(struct ip_set_req_create), len);
-			res = -EINVAL;
-			goto done;
-		}
-		req_create->name[IP_SET_MAXNAMELEN - 1] = '\0';
-		req_create->typename[IP_SET_MAXNAMELEN - 1] = '\0';
-		res = ip_set_create(req_create->name,
-				    req_create->typename,
-				    IP_SET_INVALID_ID,
-				    data + sizeof(struct ip_set_req_create),
-				    len - sizeof(struct ip_set_req_create));
-		goto done;
-	}
-	case IP_SET_OP_DESTROY:{
-		struct ip_set_req_std *req_destroy
-			= (struct ip_set_req_std *) data;
-		
-		if (len != sizeof(struct ip_set_req_std)) {
-			ip_set_printk("invalid DESTROY data (want %zu, got %u)",
-				      sizeof(struct ip_set_req_std), len);
-			res = -EINVAL;
-			goto done;
-		}
-		if (strcmp(req_destroy->name, IPSET_TOKEN_ALL) == 0) {
-			/* Destroy all sets */
-			index = IP_SET_INVALID_ID;
-		} else {
-			req_destroy->name[IP_SET_MAXNAMELEN - 1] = '\0';
-			index = ip_set_find_byname(req_destroy->name);
-
-			if (index == IP_SET_INVALID_ID) {
-				res = -ENOENT;
-				goto done;
-			}
-		}
-			
-		res = ip_set_destroy(index);
-		goto done;
-	}
-	case IP_SET_OP_FLUSH:{
-		struct ip_set_req_std *req_flush =
-			(struct ip_set_req_std *) data;
-
-		if (len != sizeof(struct ip_set_req_std)) {
-			ip_set_printk("invalid FLUSH data (want %zu, got %u)",
-				      sizeof(struct ip_set_req_std), len);
-			res = -EINVAL;
-			goto done;
-		}
-		if (strcmp(req_flush->name, IPSET_TOKEN_ALL) == 0) {
-			/* Flush all sets */
-			index = IP_SET_INVALID_ID;
-		} else {
-			req_flush->name[IP_SET_MAXNAMELEN - 1] = '\0';
-			index = ip_set_find_byname(req_flush->name);
-
-			if (index == IP_SET_INVALID_ID) {
-				res = -ENOENT;
-				goto done;
-			}
-		}
-		res = ip_set_flush(index);
-		goto done;
-	}
-	case IP_SET_OP_RENAME:{
-		struct ip_set_req_create *req_rename
-			= (struct ip_set_req_create *) data;
-
-		if (len != sizeof(struct ip_set_req_create)) {
-			ip_set_printk("invalid RENAME data (want %zu, got %u)",
-				      sizeof(struct ip_set_req_create), len);
-			res = -EINVAL;
-			goto done;
-		}
-
-		req_rename->name[IP_SET_MAXNAMELEN - 1] = '\0';
-		req_rename->typename[IP_SET_MAXNAMELEN - 1] = '\0';
-			
-		index = ip_set_find_byname(req_rename->name);
-		if (index == IP_SET_INVALID_ID) {
-			res = -ENOENT;
-			goto done;
-		}
-		res = ip_set_rename(index, req_rename->typename);
-		goto done;
-	}
-	case IP_SET_OP_SWAP:{
-		struct ip_set_req_create *req_swap
-			= (struct ip_set_req_create *) data;
-		ip_set_id_t to_index;
-
-		if (len != sizeof(struct ip_set_req_create)) {
-			ip_set_printk("invalid SWAP data (want %zu, got %u)",
-				      sizeof(struct ip_set_req_create), len);
-			res = -EINVAL;
-			goto done;
-		}
-
-		req_swap->name[IP_SET_MAXNAMELEN - 1] = '\0';
-		req_swap->typename[IP_SET_MAXNAMELEN - 1] = '\0';
-
-		index = ip_set_find_byname(req_swap->name);
-		if (index == IP_SET_INVALID_ID) {
-			res = -ENOENT;
-			goto done;
-		}
-		to_index = ip_set_find_byname(req_swap->typename);
-		if (to_index == IP_SET_INVALID_ID) {
-			res = -ENOENT;
-			goto done;
-		}
-		res = ip_set_swap(index, to_index);
-		goto done;
-	}
-	default: 
-		break;	/* Set identified by id */
-	}
-	
-	/* There we may have add/del/test/bind/unbind/test_bind operations */
-	if (*op < IP_SET_OP_ADD_IP || *op > IP_SET_OP_TEST_BIND_SET) {
-		res = -EBADMSG;
-		goto done;
-	}
-	adtfn = adtfn_table[*op - IP_SET_OP_ADD_IP].fn;
-
-	if (len < sizeof(struct ip_set_req_adt)) {
-		ip_set_printk("short data in adt request (want >=%zu, got %u)",
-			      sizeof(struct ip_set_req_adt), len);
-		res = -EINVAL;
-		goto done;
-	}
-	req_adt = (struct ip_set_req_adt *) data;
-
-	/* -U :all: :all:|:default: uses IP_SET_INVALID_ID */
-	if (!(*op == IP_SET_OP_UNBIND_SET 
-	      && req_adt->index == IP_SET_INVALID_ID)) {
-		index = ip_set_find_byindex(req_adt->index);
-		if (index == IP_SET_INVALID_ID) {
-			res = -ENOENT;
-			goto done;
-		}
-	}
-	res = adtfn(index, data, len);
-
-    done:
-	up(&ip_set_app_mutex);
-	vfree(data);
-	if (res > 0)
-		res = 0;
-	DP("final result %d", res);
-	return res;
-}
-
-static int 
-ip_set_sockfn_get(struct sock *sk, int optval, void *user, int *len)
-{
-	int res = 0;
-	unsigned *op;
-	ip_set_id_t index = IP_SET_INVALID_ID;
-	void *data;
-	int copylen = *len;
-
-	DP("optval=%d, user=%p, len=%d", optval, user, *len);
-	if (!capable(CAP_NET_ADMIN))
-		return -EPERM;
-	if (optval != SO_IP_SET)
-		return -EBADF;
-	if (*len < sizeof(unsigned)) {
-		ip_set_printk("short userdata (want >=%zu, got %d)",
-			      sizeof(unsigned), *len);
-		return -EINVAL;
-	}
-	data = vmalloc(*len);
-	if (!data) {
-		DP("out of mem for %d bytes", *len);
-		return -ENOMEM;
-	}
-	if (copy_from_user(data, user, *len) != 0) {
-		res = -EFAULT;
-		goto done;
-	}
-	if (down_interruptible(&ip_set_app_mutex)) {
-		res = -EINTR;
-		goto done;
-	}
-
-	op = (unsigned *) data;
-	DP("op=%x", *op);
-
-	if (*op < IP_SET_OP_VERSION) {
-		/* Check the version at the beginning of operations */
-		struct ip_set_req_version *req_version =
-			(struct ip_set_req_version *) data;
-		if (req_version->version != IP_SET_PROTOCOL_VERSION) {
-			res = -EPROTO;
-			goto done;
-		}
-	}
-
-	switch (*op) {
-	case IP_SET_OP_VERSION: {
-		struct ip_set_req_version *req_version =
-		    (struct ip_set_req_version *) data;
-
-		if (*len != sizeof(struct ip_set_req_version)) {
-			ip_set_printk("invalid VERSION (want %zu, got %d)",
-				      sizeof(struct ip_set_req_version),
-				      *len);
-			res = -EINVAL;
-			goto done;
-		}
-
-		req_version->version = IP_SET_PROTOCOL_VERSION;
-		res = copy_to_user(user, req_version,
-				   sizeof(struct ip_set_req_version));
-		goto done;
-	}
-	case IP_SET_OP_GET_BYNAME: {
-		struct ip_set_req_get_set *req_get
-			= (struct ip_set_req_get_set *) data;
-
-		if (*len != sizeof(struct ip_set_req_get_set)) {
-			ip_set_printk("invalid GET_BYNAME (want %zu, got %d)",
-				      sizeof(struct ip_set_req_get_set), *len);
-			res = -EINVAL;
-			goto done;
-		}
-		req_get->set.name[IP_SET_MAXNAMELEN - 1] = '\0';
-		index = ip_set_find_byname(req_get->set.name);
-		req_get->set.index = index;
-		goto copy;
-	}
-	case IP_SET_OP_GET_BYINDEX: {
-		struct ip_set_req_get_set *req_get
-			= (struct ip_set_req_get_set *) data;
-
-		if (*len != sizeof(struct ip_set_req_get_set)) {
-			ip_set_printk("invalid GET_BYINDEX (want %zu, got %d)",
-				      sizeof(struct ip_set_req_get_set), *len);
-			res = -EINVAL;
-			goto done;
-		}
-		req_get->set.name[IP_SET_MAXNAMELEN - 1] = '\0';
-		index = ip_set_find_byindex(req_get->set.index);
-		strncpy(req_get->set.name,
-			index == IP_SET_INVALID_ID ? ""
-			: ip_set_list[index]->name, IP_SET_MAXNAMELEN);
-		goto copy;
-	}
-	case IP_SET_OP_ADT_GET: {
-		struct ip_set_req_adt_get *req_get
-			= (struct ip_set_req_adt_get *) data;
-
-		if (*len != sizeof(struct ip_set_req_adt_get)) {
-			ip_set_printk("invalid ADT_GET (want %zu, got %d)",
-				      sizeof(struct ip_set_req_adt_get), *len);
-			res = -EINVAL;
-			goto done;
-		}
-		req_get->set.name[IP_SET_MAXNAMELEN - 1] = '\0';
-		index = ip_set_find_byname(req_get->set.name);
-		if (index != IP_SET_INVALID_ID) {
-			req_get->set.index = index;
-			strncpy(req_get->typename,
-				ip_set_list[index]->type->typename,
-				IP_SET_MAXNAMELEN - 1);
-		} else {
-			res = -ENOENT;
-			goto done;
-		}
-		goto copy;
-	}
-	case IP_SET_OP_MAX_SETS: {
-		struct ip_set_req_max_sets *req_max_sets
-			= (struct ip_set_req_max_sets *) data;
-		ip_set_id_t i;
-
-		if (*len != sizeof(struct ip_set_req_max_sets)) {
-			ip_set_printk("invalid MAX_SETS (want %zu, got %d)",
-				      sizeof(struct ip_set_req_max_sets), *len);
-			res = -EINVAL;
-			goto done;
-		}
-
-		if (strcmp(req_max_sets->set.name, IPSET_TOKEN_ALL) == 0) {
-			req_max_sets->set.index = IP_SET_INVALID_ID;
-		} else {
-			req_max_sets->set.name[IP_SET_MAXNAMELEN - 1] = '\0';
-			req_max_sets->set.index = 
-				ip_set_find_byname(req_max_sets->set.name);
-			if (req_max_sets->set.index == IP_SET_INVALID_ID) {
-				res = -ENOENT;
-				goto done;
-			}
-		}
-		req_max_sets->max_sets = ip_set_max;
-		req_max_sets->sets = 0;
-		for (i = 0; i < ip_set_max; i++) {
-			if (ip_set_list[i] != NULL)
-				req_max_sets->sets++;
-		}
-		goto copy;
-	}
-	case IP_SET_OP_LIST_SIZE: 
-	case IP_SET_OP_SAVE_SIZE: {
-		struct ip_set_req_setnames *req_setnames
-			= (struct ip_set_req_setnames *) data;
-		struct ip_set_name_list *name_list;
-		struct ip_set *set;
-		ip_set_id_t i;
-		int used;
-
-		if (*len < sizeof(struct ip_set_req_setnames)) {
-			ip_set_printk("short LIST_SIZE (want >=%zu, got %d)",
-				      sizeof(struct ip_set_req_setnames), *len);
-			res = -EINVAL;
-			goto done;
-		}
-
-		req_setnames->size = 0;
-		used = sizeof(struct ip_set_req_setnames);
-		for (i = 0; i < ip_set_max; i++) {
-			if (ip_set_list[i] == NULL)
-				continue;
-			name_list = (struct ip_set_name_list *) 
-				(data + used);
-			used += sizeof(struct ip_set_name_list);
-			if (used > copylen) {
-				res = -EAGAIN;
-				goto done;
-			}
-			set = ip_set_list[i];
-			/* Fill in index, name, etc. */
-			name_list->index = i;
-			name_list->id = set->id;
-			strncpy(name_list->name,
-				set->name,
-				IP_SET_MAXNAMELEN - 1);
-			strncpy(name_list->typename,
-				set->type->typename,
-				IP_SET_MAXNAMELEN - 1);
-			DP("filled %s of type %s, index %u\n",
-			   name_list->name, name_list->typename,
-			   name_list->index);
-			if (!(req_setnames->index == IP_SET_INVALID_ID
-			      || req_setnames->index == i))
-			      continue;
-			/* Update size */
-			switch (*op) {
-			case IP_SET_OP_LIST_SIZE: {
-				req_setnames->size += sizeof(struct ip_set_list)
-					+ set->type->header_size
-					+ set->type->list_members_size(set);
-				FOREACH_HASH_DO(__set_hash_bindings_size_list, 
-						i, &req_setnames->size);
-				break;
-			}
-			case IP_SET_OP_SAVE_SIZE: {
-				req_setnames->size += sizeof(struct ip_set_save)
-					+ set->type->header_size
-					+ set->type->list_members_size(set);
-				FOREACH_HASH_DO(__set_hash_bindings_size_save,
-						i, &req_setnames->size);
-				break;
-			}
-			default:
-				break;
-			}
-		}
-		if (copylen != used) {
-			res = -EAGAIN;
-			goto done;
-		}
-		goto copy;
-	}
-	case IP_SET_OP_LIST: {
-		struct ip_set_req_list *req_list
-			= (struct ip_set_req_list *) data;
-		ip_set_id_t i;
-		int used;
-
-		if (*len < sizeof(struct ip_set_req_list)) {
-			ip_set_printk("short LIST (want >=%zu, got %d)",
-				      sizeof(struct ip_set_req_list), *len);
-			res = -EINVAL;
-			goto done;
-		}
-		index = req_list->index;
-		if (index != IP_SET_INVALID_ID
-		    && ip_set_find_byindex(index) != index) {
-		    	res = -ENOENT;
-		    	goto done;
-		}
-		used = 0;
-		if (index == IP_SET_INVALID_ID) {
-			/* List all sets */
-			for (i = 0; i < ip_set_max && res == 0; i++) {
-				if (ip_set_list[i] != NULL)
-					res = ip_set_list_set(i, data, &used, *len);
-			}
-		} else {
-			/* List an individual set */
-			res = ip_set_list_set(index, data, &used, *len);
-		}
-		if (res != 0)
-			goto done;
-		else if (copylen != used) {
-			res = -EAGAIN;
-			goto done;
-		}
-		goto copy;
-	}
-	case IP_SET_OP_SAVE: {
-		struct ip_set_req_list *req_save
-			= (struct ip_set_req_list *) data;
-		ip_set_id_t i;
-		int used;
-
-		if (*len < sizeof(struct ip_set_req_list)) {
-			ip_set_printk("short SAVE (want >=%zu, got %d)",
-				      sizeof(struct ip_set_req_list), *len);
-			res = -EINVAL;
-			goto done;
-		}
-		index = req_save->index;
-		if (index != IP_SET_INVALID_ID
-		    && ip_set_find_byindex(index) != index) {
-		    	res = -ENOENT;
-		    	goto done;
-		}
-		used = 0;
-		if (index == IP_SET_INVALID_ID) {
-			/* Save all sets */
-			for (i = 0; i < ip_set_max && res == 0; i++) {
-				if (ip_set_list[i] != NULL)
-					res = ip_set_save_set(i, data, &used, *len);
-			}
-		} else {
-			/* Save an individual set */
-			res = ip_set_save_set(index, data, &used, *len);
-		}
-		if (res == 0)
-			res = ip_set_save_bindings(index, data, &used, *len);
-			
-		if (res != 0)
-			goto done;
-		else if (copylen != used) {
-			res = -EAGAIN;
-			goto done;
-		}
-		goto copy;
-	}
-	case IP_SET_OP_RESTORE: {
-		struct ip_set_req_setnames *req_restore
-			= (struct ip_set_req_setnames *) data;
-		int line;
-
-		if (*len < sizeof(struct ip_set_req_setnames)
-		    || *len != req_restore->size) {
-			ip_set_printk("invalid RESTORE (want =%zu, got %d)",
-				      req_restore->size, *len);
-			res = -EINVAL;
-			goto done;
-		}
-		line = ip_set_restore(data + sizeof(struct ip_set_req_setnames),
-				      req_restore->size - sizeof(struct ip_set_req_setnames));
-		DP("ip_set_restore: %u", line);
-		if (line != 0) {
-			res = -EAGAIN;
-			req_restore->size = line;
-			copylen = sizeof(struct ip_set_req_setnames);
-			goto copy;
-		}
-		goto done;
-	}
-	default:
-		res = -EBADMSG;
-		goto done;
-	}	/* end of switch(op) */
-
-    copy:
-   	DP("set %s, copylen %u", index != IP_SET_INVALID_ID
-   	             		 && ip_set_list[index]
-   	             ? ip_set_list[index]->name
-   	             : ":all:", copylen);
-	res = copy_to_user(user, data, copylen);
-    	
-    done:
-	up(&ip_set_app_mutex);
-	vfree(data);
-	if (res > 0)
-		res = 0;
-	DP("final result %d", res);
-	return res;
-}
-
-static struct nf_sockopt_ops so_set = {
-	.pf 		= PF_INET,
-	.set_optmin 	= SO_IP_SET,
-	.set_optmax 	= SO_IP_SET + 1,
-	.set 		= &ip_set_sockfn_set,
-	.get_optmin 	= SO_IP_SET,
-	.get_optmax	= SO_IP_SET + 1,
-	.get		= &ip_set_sockfn_get,
-	.use		= 0
-};
-
-static int max_sets, hash_size;
-module_param(max_sets, int, 0600);
-MODULE_PARM_DESC(max_sets, "maximal number of sets");
-module_param(hash_size, int, 0600);
-MODULE_PARM_DESC(hash_size, "hash size for bindings");
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
-MODULE_DESCRIPTION("module implementing core IP set support");
-
-static int __init init(void)
-{
-	int res;
-	ip_set_id_t i;
-
-	get_random_bytes(&ip_set_hash_random, 4);
-	if (max_sets)
-		ip_set_max = max_sets;
-	ip_set_list = vmalloc(sizeof(struct ip_set *) * ip_set_max);
-	if (!ip_set_list) {
-		printk(KERN_ERR "Unable to create ip_set_list\n");
-		return -ENOMEM;
-	}
-	memset(ip_set_list, 0, sizeof(struct ip_set *) * ip_set_max);
-	if (hash_size)
-		ip_set_bindings_hash_size = hash_size;
-	ip_set_hash = vmalloc(sizeof(struct list_head) * ip_set_bindings_hash_size);
-	if (!ip_set_hash) {
-		printk(KERN_ERR "Unable to create ip_set_hash\n");
-		vfree(ip_set_list);
-		return -ENOMEM;
-	}
-	for (i = 0; i < ip_set_bindings_hash_size; i++)
-		INIT_LIST_HEAD(&ip_set_hash[i]);
-
-	INIT_LIST_HEAD(&set_type_list);
-
-	res = nf_register_sockopt(&so_set);
-	if (res != 0) {
-		ip_set_printk("SO_SET registry failed: %d", res);
-		vfree(ip_set_list);
-		vfree(ip_set_hash);
-		return res;
-	}
-	return 0;
-}
-
-static void __exit fini(void)
-{
-	/* There can't be any existing set or binding */
-	nf_unregister_sockopt(&so_set);
-	vfree(ip_set_list);
-	vfree(ip_set_hash);
-	DP("these are the famous last words");
-}
-
-EXPORT_SYMBOL(ip_set_register_set_type);
-EXPORT_SYMBOL(ip_set_unregister_set_type);
-
-EXPORT_SYMBOL(ip_set_get_byname);
-EXPORT_SYMBOL(ip_set_get_byindex);
-EXPORT_SYMBOL(ip_set_put);
-
-EXPORT_SYMBOL(ip_set_addip_kernel);
-EXPORT_SYMBOL(ip_set_delip_kernel);
-EXPORT_SYMBOL(ip_set_testip_kernel);
-
-module_init(init);
-module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_iphash.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_iphash.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_iphash.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_iphash.c	1970-01-01 01:00:00.000000000 +0100
@@ -1,398 +0,0 @@
-/* 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/netfilter_ipv4/ip_tables.h>
-#include <linux/netfilter_ipv4/ip_set.h>
-#include <linux/errno.h>
-#include <asm/uaccess.h>
-#include <asm/bitops.h>
-#include <linux/spinlock.h>
-#include <linux/vmalloc.h>
-#include <linux/random.h>
-
-#include <net/ip.h>
-
-#include <linux/netfilter_ipv4/ip_set_malloc.h>
-#include <linux/netfilter_ipv4/ip_set_iphash.h>
-#include <linux/netfilter_ipv4/ip_set_jhash.h>
-
-static inline __u32
-jhash_ip(const struct ip_set_iphash *map, uint16_t i, ip_set_ip_t ip)
-{
-	return jhash_1word(ip, *(((uint32_t *) map->initval) + i));
-}
-
-static inline __u32
-hash_id(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
-	__u32 id;
-	u_int16_t i;
-	ip_set_ip_t *elem;
-
-	*hash_ip = ip & map->netmask;
-	DP("set: %s, ip:%u.%u.%u.%u, %u.%u.%u.%u, %u.%u.%u.%u",
-	   set->name, HIPQUAD(ip), HIPQUAD(*hash_ip), HIPQUAD(map->netmask));
-	
-	for (i = 0; i < map->probes; i++) {
-		id = jhash_ip(map, i, *hash_ip) % map->hashsize;
-		DP("hash key: %u", id);
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id);
-		if (*elem == *hash_ip)
-			return id;
-		/* No shortcut at testing - there can be deleted
-		 * entries. */
-	}
-	return UINT_MAX;
-}
-
-static inline int
-__testip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	return (hash_id(set, ip, hash_ip) != UINT_MAX);
-}
-
-static int
-testip(struct ip_set *set, const void *data, size_t size,
-       ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_iphash *req = 
-	    (struct ip_set_req_iphash *) data;
-
-	if (size != sizeof(struct ip_set_req_iphash)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_iphash),
-			      size);
-		return -EINVAL;
-	}
-	return __testip(set, req->ip, hash_ip);
-}
-
-static int
-testip_kernel(struct ip_set *set, 
-	      const struct sk_buff *skb,
-	      ip_set_ip_t *hash_ip,
-	      const u_int32_t *flags,
-	      unsigned char index)
-{
-	return __testip(set,
-			ntohl(flags[index] & IPSET_SRC 
-				? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-			hash_ip);
-}
-
-static inline int
-__addip(struct ip_set_iphash *map, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	__u32 probe;
-	u_int16_t i;
-	ip_set_ip_t *elem;
-
-	*hash_ip = ip & map->netmask;
-	
-	for (i = 0; i < map->probes; i++) {
-		probe = jhash_ip(map, i, *hash_ip) % map->hashsize;
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, probe);
-		if (*elem == *hash_ip)
-			return -EEXIST;
-		if (!*elem) {
-			*elem = *hash_ip;
-			return 0;
-		}
-	}
-	/* Trigger rehashing */
-	return -EAGAIN;
-}
-
-static int
-addip(struct ip_set *set, const void *data, size_t size,
-        ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_iphash *req = 
-	    (struct ip_set_req_iphash *) data;
-
-	if (size != sizeof(struct ip_set_req_iphash)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_iphash),
-			      size);
-		return -EINVAL;
-	}
-	return __addip((struct ip_set_iphash *) set->data, req->ip, hash_ip);
-}
-
-static int
-addip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	return __addip((struct ip_set_iphash *) set->data,
-		       ntohl(flags[index] & IPSET_SRC 
-		       		? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-		       hash_ip);
-}
-
-static int retry(struct ip_set *set)
-{
-	struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
-	ip_set_ip_t hash_ip, *elem;
-	void *members;
-	u_int32_t i, hashsize = map->hashsize;
-	int res;
-	struct ip_set_iphash *tmp;
-	
-	if (map->resize == 0)
-		return -ERANGE;
-
-    again:
-    	res = 0;
-    	
-	/* Calculate new hash size */
-	hashsize += (hashsize * map->resize)/100;
-	if (hashsize == map->hashsize)
-		hashsize++;
-	
-	ip_set_printk("rehashing of set %s triggered: "
-		      "hashsize grows from %u to %u",
-		      set->name, map->hashsize, hashsize);
-
-	tmp = kmalloc(sizeof(struct ip_set_iphash) 
-		      + map->probes * sizeof(uint32_t), GFP_ATOMIC);
-	if (!tmp) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_set_iphash)
-		   + map->probes * sizeof(uint32_t));
-		return -ENOMEM;
-	}
-	tmp->members = harray_malloc(hashsize, sizeof(ip_set_ip_t), GFP_ATOMIC);
-	if (!tmp->members) {
-		DP("out of memory for %d bytes", hashsize * sizeof(ip_set_ip_t));
-		kfree(tmp);
-		return -ENOMEM;
-	}
-	tmp->hashsize = hashsize;
-	tmp->probes = map->probes;
-	tmp->resize = map->resize;
-	tmp->netmask = map->netmask;
-	memcpy(tmp->initval, map->initval, map->probes * sizeof(uint32_t));
-	
-	write_lock_bh(&set->lock);
-	map = (struct ip_set_iphash *) set->data; /* Play safe */
-	for (i = 0; i < map->hashsize && res == 0; i++) {
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);	
-		if (*elem)
-			res = __addip(tmp, *elem, &hash_ip);
-	}
-	if (res) {
-		/* Failure, try again */
-		write_unlock_bh(&set->lock);
-		harray_free(tmp->members);
-		kfree(tmp);
-		goto again;
-	}
-	
-	/* Success at resizing! */
-	members = map->members;
-
-	map->hashsize = tmp->hashsize;
-	map->members = tmp->members;
-	write_unlock_bh(&set->lock);
-
-	harray_free(members);
-	kfree(tmp);
-
-	return 0;
-}
-
-static inline int
-__delip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
-	ip_set_ip_t id = hash_id(set, ip, hash_ip);
-	ip_set_ip_t *elem;
-
-	if (id == UINT_MAX)
-		return -EEXIST;
-		
-	elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id);
-	*elem = 0;
-
-	return 0;
-}
-
-static int
-delip(struct ip_set *set, const void *data, size_t size,
-        ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_iphash *req =
-	    (struct ip_set_req_iphash *) data;
-
-	if (size != sizeof(struct ip_set_req_iphash)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_iphash),
-			      size);
-		return -EINVAL;
-	}
-	return __delip(set, req->ip, hash_ip);
-}
-
-static int
-delip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	return __delip(set,
-		       ntohl(flags[index] & IPSET_SRC 
-				? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-		       hash_ip);
-}
-
-static int create(struct ip_set *set, const void *data, size_t size)
-{
-	struct ip_set_req_iphash_create *req =
-	    (struct ip_set_req_iphash_create *) data;
-	struct ip_set_iphash *map;
-	uint16_t i;
-
-	if (size != sizeof(struct ip_set_req_iphash_create)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			       sizeof(struct ip_set_req_iphash_create),
-			       size);
-		return -EINVAL;
-	}
-
-	if (req->hashsize < 1) {
-		ip_set_printk("hashsize too small");
-		return -ENOEXEC;
-	}
-
-	if (req->probes < 1) {
-		ip_set_printk("probes too small");
-		return -ENOEXEC;
-	}
-
-	map = kmalloc(sizeof(struct ip_set_iphash) 
-		      + req->probes * sizeof(uint32_t), GFP_KERNEL);
-	if (!map) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_set_iphash)
-		   + req->probes * sizeof(uint32_t));
-		return -ENOMEM;
-	}
-	for (i = 0; i < req->probes; i++)
-		get_random_bytes(((uint32_t *) map->initval)+i, 4);
-	map->hashsize = req->hashsize;
-	map->probes = req->probes;
-	map->resize = req->resize;
-	map->netmask = req->netmask;
-	map->members = harray_malloc(map->hashsize, sizeof(ip_set_ip_t), GFP_KERNEL);
-	if (!map->members) {
-		DP("out of memory for %d bytes", map->hashsize * sizeof(ip_set_ip_t));
-		kfree(map);
-		return -ENOMEM;
-	}
-
-	set->data = map;
-	return 0;
-}
-
-static void destroy(struct ip_set *set)
-{
-	struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
-
-	harray_free(map->members);
-	kfree(map);
-
-	set->data = NULL;
-}
-
-static void flush(struct ip_set *set)
-{
-	struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
-	harray_flush(map->members, map->hashsize, sizeof(ip_set_ip_t));
-}
-
-static void list_header(const struct ip_set *set, void *data)
-{
-	struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
-	struct ip_set_req_iphash_create *header =
-	    (struct ip_set_req_iphash_create *) data;
-
-	header->hashsize = map->hashsize;
-	header->probes = map->probes;
-	header->resize = map->resize;
-	header->netmask = map->netmask;
-}
-
-static int list_members_size(const struct ip_set *set)
-{
-	struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
-
-	return (map->hashsize * sizeof(ip_set_ip_t));
-}
-
-static void list_members(const struct ip_set *set, void *data)
-{
-	struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
-	ip_set_ip_t i, *elem;
-
-	for (i = 0; i < map->hashsize; i++) {
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);	
-		((ip_set_ip_t *)data)[i] = *elem;
-	}
-}
-
-static struct ip_set_type ip_set_iphash = {
-	.typename		= SETTYPE_NAME,
-	.features		= IPSET_TYPE_IP | IPSET_DATA_SINGLE,
-	.protocol_version	= IP_SET_PROTOCOL_VERSION,
-	.create			= &create,
-	.destroy		= &destroy,
-	.flush			= &flush,
-	.reqsize		= sizeof(struct ip_set_req_iphash),
-	.addip			= &addip,
-	.addip_kernel		= &addip_kernel,
-	.retry			= &retry,
-	.delip			= &delip,
-	.delip_kernel		= &delip_kernel,
-	.testip			= &testip,
-	.testip_kernel		= &testip_kernel,
-	.header_size		= sizeof(struct ip_set_req_iphash_create),
-	.list_header		= &list_header,
-	.list_members_size	= &list_members_size,
-	.list_members		= &list_members,
-	.me			= THIS_MODULE,
-};
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
-MODULE_DESCRIPTION("iphash type of IP sets");
-
-static int __init init(void)
-{
-	return ip_set_register_set_type(&ip_set_iphash);
-}
-
-static void __exit fini(void)
-{
-	/* FIXME: possible race with ip_set_create() */
-	ip_set_unregister_set_type(&ip_set_iphash);
-}
-
-module_init(init);
-module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_ipmap.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_ipmap.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_ipmap.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_ipmap.c	1970-01-01 01:00:00.000000000 +0100
@@ -1,327 +0,0 @@
-/* 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/netfilter_ipv4/ip_tables.h>
-#include <linux/netfilter_ipv4/ip_set.h>
-#include <linux/errno.h>
-#include <asm/uaccess.h>
-#include <asm/bitops.h>
-#include <linux/spinlock.h>
-
-#include <linux/netfilter_ipv4/ip_set_ipmap.h>
-
-static inline ip_set_ip_t
-ip_to_id(const struct ip_set_ipmap *map, ip_set_ip_t ip)
-{
-	return (ip - map->first_ip)/map->hosts;
-}
-
-static inline int
-__testip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
-	
-	if (ip < map->first_ip || ip > map->last_ip)
-		return -ERANGE;
-
-	*hash_ip = ip & map->netmask;
-	DP("set: %s, ip:%u.%u.%u.%u, %u.%u.%u.%u",
-	   set->name, HIPQUAD(ip), HIPQUAD(*hash_ip));
-	return !!test_bit(ip_to_id(map, *hash_ip), map->members);
-}
-
-static int
-testip(struct ip_set *set, const void *data, size_t size,
-       ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_ipmap *req = 
-	    (struct ip_set_req_ipmap *) data;
-
-	if (size != sizeof(struct ip_set_req_ipmap)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_ipmap),
-			      size);
-		return -EINVAL;
-	}
-	return __testip(set, req->ip, hash_ip);
-}
-
-static int
-testip_kernel(struct ip_set *set, 
-	      const struct sk_buff *skb,
-	      ip_set_ip_t *hash_ip,
-	      const u_int32_t *flags,
-	      unsigned char index)
-{
-	int res;
-	
-	DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u",
-	   flags[index] & IPSET_SRC ? "SRC" : "DST",
-	   NIPQUAD(skb->nh.iph->saddr),
-	   NIPQUAD(skb->nh.iph->daddr));
-
-	res =  __testip(set,
-			ntohl(flags[index] & IPSET_SRC 
-				? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-			hash_ip);
-	return (res < 0 ? 0 : res);
-}
-
-static inline int
-__addip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
-
-	if (ip < map->first_ip || ip > map->last_ip)
-		return -ERANGE;
-
-	*hash_ip = ip & map->netmask;
-	DP("%u.%u.%u.%u, %u.%u.%u.%u", HIPQUAD(ip), HIPQUAD(*hash_ip));
-	if (test_and_set_bit(ip_to_id(map, *hash_ip), map->members))
-		return -EEXIST;
-
-	return 0;
-}
-
-static int
-addip(struct ip_set *set, const void *data, size_t size,
-      ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_ipmap *req = 
-	    (struct ip_set_req_ipmap *) data;
-
-	if (size != sizeof(struct ip_set_req_ipmap)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_ipmap),
-			      size);
-		return -EINVAL;
-	}
-	DP("%u.%u.%u.%u", HIPQUAD(req->ip));
-	return __addip(set, req->ip, hash_ip);
-}
-
-static int
-addip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	return __addip(set,
-		       ntohl(flags[index] & IPSET_SRC 
-		       		? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-		       hash_ip);
-}
-
-static inline int 
-__delip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
-
-	if (ip < map->first_ip || ip > map->last_ip)
-		return -ERANGE;
-
-	*hash_ip = ip & map->netmask;
-	DP("%u.%u.%u.%u, %u.%u.%u.%u", HIPQUAD(ip), HIPQUAD(*hash_ip));
-	if (!test_and_clear_bit(ip_to_id(map, *hash_ip), map->members))
-		return -EEXIST;
-	
-	return 0;
-}
-
-static int
-delip(struct ip_set *set, const void *data, size_t size,
-      ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_ipmap *req =
-	    (struct ip_set_req_ipmap *) data;
-
-	if (size != sizeof(struct ip_set_req_ipmap)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_ipmap),
-			      size);
-		return -EINVAL;
-	}
-	return __delip(set, req->ip, hash_ip);
-}
-
-static int
-delip_kernel(struct ip_set *set,
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	return __delip(set,
-		       ntohl(flags[index] & IPSET_SRC 
-				? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-		       hash_ip);
-}
-
-static int create(struct ip_set *set, const void *data, size_t size)
-{
-	int newbytes;
-	struct ip_set_req_ipmap_create *req =
-	    (struct ip_set_req_ipmap_create *) data;
-	struct ip_set_ipmap *map;
-
-	if (size != sizeof(struct ip_set_req_ipmap_create)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_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 ip_set_ipmap), GFP_KERNEL);
-	if (!map) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_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;
-		ip_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) {
-		ip_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 ip_set *set)
-{
-	struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
-	
-	kfree(map->members);
-	kfree(map);
-	
-	set->data = NULL;
-}
-
-static void flush(struct ip_set *set)
-{
-	struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
-	memset(map->members, 0, bitmap_bytes(0, map->sizeid - 1));
-}
-
-static void list_header(const struct ip_set *set, void *data)
-{
-	struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
-	struct ip_set_req_ipmap_create *header =
-	    (struct ip_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 ip_set *set)
-{
-	struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
-
-	return bitmap_bytes(0, map->sizeid - 1);
-}
-
-static void list_members(const struct ip_set *set, void *data)
-{
-	struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
-	int bytes = bitmap_bytes(0, map->sizeid - 1);
-
-	memcpy(data, map->members, bytes);
-}
-
-static struct ip_set_type ip_set_ipmap = {
-	.typename		= SETTYPE_NAME,
-	.features		= IPSET_TYPE_IP | IPSET_DATA_SINGLE,
-	.protocol_version	= IP_SET_PROTOCOL_VERSION,
-	.create			= &create,
-	.destroy		= &destroy,
-	.flush			= &flush,
-	.reqsize		= sizeof(struct ip_set_req_ipmap),
-	.addip			= &addip,
-	.addip_kernel		= &addip_kernel,
-	.delip			= &delip,
-	.delip_kernel		= &delip_kernel,
-	.testip			= &testip,
-	.testip_kernel		= &testip_kernel,
-	.header_size		= sizeof(struct ip_set_req_ipmap_create),
-	.list_header		= &list_header,
-	.list_members_size	= &list_members_size,
-	.list_members		= &list_members,
-	.me			= THIS_MODULE,
-};
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
-MODULE_DESCRIPTION("ipmap type of IP sets");
-
-static int __init init(void)
-{
-	return ip_set_register_set_type(&ip_set_ipmap);
-}
-
-static void __exit fini(void)
-{
-	/* FIXME: possible race with ip_set_create() */
-	ip_set_unregister_set_type(&ip_set_ipmap);
-}
-
-module_init(init);
-module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_ipporthash.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_ipporthash.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_ipporthash.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_ipporthash.c	1970-01-01 01:00:00.000000000 +0100
@@ -1,524 +0,0 @@
-/* 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/netfilter_ipv4/ip_tables.h>
-#include <linux/netfilter_ipv4/ip_set.h>
-#include <linux/errno.h>
-#include <asm/uaccess.h>
-#include <asm/bitops.h>
-#include <linux/spinlock.h>
-#include <linux/vmalloc.h>
-#include <linux/random.h>
-
-#include <net/ip.h>
-
-#include <linux/netfilter_ipv4/ip_set_malloc.h>
-#include <linux/netfilter_ipv4/ip_set_ipporthash.h>
-#include <linux/netfilter_ipv4/ip_set_jhash.h>
-
-/* We must handle non-linear skbs */
-static inline ip_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 & IPSET_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 & IPSET_SRC ?
-			     udph.source : udph.dest);
-	    }
-	default:
-		return INVALID_PORT;
-	}
-}
-
-static inline __u32
-jhash_ip(const struct ip_set_ipporthash *map, uint16_t i, ip_set_ip_t ip)
-{
-	return jhash_1word(ip, *(((uint32_t *) map->initval) + i));
-}
-
-#define HASH_IP(map, ip, port) (port + ((ip - ((map)->first_ip)) << 16))
-
-static inline __u32
-hash_id(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t port,
-	ip_set_ip_t *hash_ip)
-{
-	struct ip_set_ipporthash *map = 
-		(struct ip_set_ipporthash *) set->data;
-	__u32 id;
-	u_int16_t i;
-	ip_set_ip_t *elem;
-
-	*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));
-	
-	for (i = 0; i < map->probes; i++) {
-		id = jhash_ip(map, i, *hash_ip) % map->hashsize;
-		DP("hash key: %u", id);
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id);
-		if (*elem == *hash_ip)
-			return id;
-		/* No shortcut at testing - there can be deleted
-		 * entries. */
-	}
-	return UINT_MAX;
-}
-
-static inline int
-__testip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t port,
-	 ip_set_ip_t *hash_ip)
-{
-	struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
-	
-	if (ip < map->first_ip || ip > map->last_ip)
-		return -ERANGE;
-
-	return (hash_id(set, ip, port, hash_ip) != UINT_MAX);
-}
-
-static int
-testip(struct ip_set *set, const void *data, size_t size,
-       ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_ipporthash *req = 
-	    (struct ip_set_req_ipporthash *) data;
-
-	if (size != sizeof(struct ip_set_req_ipporthash)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_ipporthash),
-			      size);
-		return -EINVAL;
-	}
-	return __testip(set, req->ip, req->port, hash_ip);
-}
-
-static int
-testip_kernel(struct ip_set *set, 
-	      const struct sk_buff *skb,
-	      ip_set_ip_t *hash_ip,
-	      const u_int32_t *flags,
-	      unsigned char index)
-{
-	ip_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] & IPSET_SRC ? "SRC" : "DST",
-	   NIPQUAD(skb->nh.iph->saddr),
-	   NIPQUAD(skb->nh.iph->daddr));
-	DP("flag %s port %u",
-	   flags[index+1] & IPSET_SRC ? "SRC" : "DST", 
-	   port);	
-	if (port == INVALID_PORT)
-		return 0;	
-
-	return __testip(set,
-			ntohl(flags[index] & IPSET_SRC 
-					? skb->nh.iph->saddr 
-					: skb->nh.iph->daddr),
-			port,
-			hash_ip);
-}
-
-static inline int
-__add_haship(struct ip_set_ipporthash *map, ip_set_ip_t hash_ip)
-{
-	__u32 probe;
-	u_int16_t i;
-	ip_set_ip_t *elem;
-
-	for (i = 0; i < map->probes; i++) {
-		probe = jhash_ip(map, i, hash_ip) % map->hashsize;
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, probe);
-		if (*elem == hash_ip)
-			return -EEXIST;
-		if (!*elem) {
-			*elem = hash_ip;
-			return 0;
-		}
-	}
-	/* Trigger rehashing */
-	return -EAGAIN;
-}
-
-static inline int
-__addip(struct ip_set_ipporthash *map, ip_set_ip_t ip, ip_set_ip_t port,
-	ip_set_ip_t *hash_ip)
-{
-	if (ip < map->first_ip || ip > map->last_ip)
-		return -ERANGE;
-
-	*hash_ip = HASH_IP(map, ip, port);
-	
-	return __add_haship(map, *hash_ip);
-}
-
-static int
-addip(struct ip_set *set, const void *data, size_t size,
-        ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_ipporthash *req = 
-	    (struct ip_set_req_ipporthash *) data;
-
-	if (size != sizeof(struct ip_set_req_ipporthash)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_ipporthash),
-			      size);
-		return -EINVAL;
-	}
-	return __addip((struct ip_set_ipporthash *) set->data, 
-			req->ip, req->port, hash_ip);
-}
-
-static int
-addip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	ip_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] & IPSET_SRC ? "SRC" : "DST",
-	   NIPQUAD(skb->nh.iph->saddr),
-	   NIPQUAD(skb->nh.iph->daddr));
-	DP("flag %s port %u", 
-	   flags[index+1] & IPSET_SRC ? "SRC" : "DST", 
-	   port);	
-	if (port == INVALID_PORT)
-		return -EINVAL;	
-
-	return __addip((struct ip_set_ipporthash *) set->data,
-		       ntohl(flags[index] & IPSET_SRC 
-		       		? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-		       port,
-		       hash_ip);
-}
-
-static int retry(struct ip_set *set)
-{
-	struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
-	ip_set_ip_t *elem;
-	void *members;
-	u_int32_t i, hashsize = map->hashsize;
-	int res;
-	struct ip_set_ipporthash *tmp;
-	
-	if (map->resize == 0)
-		return -ERANGE;
-
-    again:
-    	res = 0;
-    	
-	/* Calculate new hash size */
-	hashsize += (hashsize * map->resize)/100;
-	if (hashsize == map->hashsize)
-		hashsize++;
-	
-	ip_set_printk("rehashing of set %s triggered: "
-		      "hashsize grows from %u to %u",
-		      set->name, map->hashsize, hashsize);
-
-	tmp = kmalloc(sizeof(struct ip_set_ipporthash) 
-		      + map->probes * sizeof(uint32_t), GFP_ATOMIC);
-	if (!tmp) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_set_ipporthash)
-		   + map->probes * sizeof(uint32_t));
-		return -ENOMEM;
-	}
-	tmp->members = harray_malloc(hashsize, sizeof(ip_set_ip_t), GFP_ATOMIC);
-	if (!tmp->members) {
-		DP("out of memory for %d bytes", hashsize * sizeof(ip_set_ip_t));
-		kfree(tmp);
-		return -ENOMEM;
-	}
-	tmp->hashsize = hashsize;
-	tmp->probes = map->probes;
-	tmp->resize = map->resize;
-	tmp->first_ip = map->first_ip;
-	tmp->last_ip = map->last_ip;
-	memcpy(tmp->initval, map->initval, map->probes * sizeof(uint32_t));
-	
-	write_lock_bh(&set->lock);
-	map = (struct ip_set_ipporthash *) set->data; /* Play safe */
-	for (i = 0; i < map->hashsize && res == 0; i++) {
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);	
-		if (*elem)
-			res = __add_haship(tmp, *elem);
-	}
-	if (res) {
-		/* Failure, try again */
-		write_unlock_bh(&set->lock);
-		harray_free(tmp->members);
-		kfree(tmp);
-		goto again;
-	}
-	
-	/* Success at resizing! */
-	members = map->members;
-
-	map->hashsize = tmp->hashsize;
-	map->members = tmp->members;
-	write_unlock_bh(&set->lock);
-
-	harray_free(members);
-	kfree(tmp);
-
-	return 0;
-}
-
-static inline int
-__delip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t port,
-	ip_set_ip_t *hash_ip)
-{
-	struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
-	ip_set_ip_t id;
-	ip_set_ip_t *elem;
-
-	if (ip < map->first_ip || ip > map->last_ip)
-		return -ERANGE;
-
-	id = hash_id(set, ip, port, hash_ip);
-
-	if (id == UINT_MAX)
-		return -EEXIST;
-		
-	elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id);
-	*elem = 0;
-
-	return 0;
-}
-
-static int
-delip(struct ip_set *set, const void *data, size_t size,
-        ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_ipporthash *req =
-	    (struct ip_set_req_ipporthash *) data;
-
-	if (size != sizeof(struct ip_set_req_ipporthash)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_ipporthash),
-			      size);
-		return -EINVAL;
-	}
-	return __delip(set, req->ip, req->port, hash_ip);
-}
-
-static int
-delip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	ip_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] & IPSET_SRC ? "SRC" : "DST",
-	   NIPQUAD(skb->nh.iph->saddr),
-	   NIPQUAD(skb->nh.iph->daddr));
-	DP("flag %s port %u",
-	   flags[index+1] & IPSET_SRC ? "SRC" : "DST", 
-	   port);	
-	if (port == INVALID_PORT)
-		return -EINVAL;	
-
-	return __delip(set,
-		       ntohl(flags[index] & IPSET_SRC 
-		       		? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-		       port,
-		       hash_ip);
-}
-
-static int create(struct ip_set *set, const void *data, size_t size)
-{
-	struct ip_set_req_ipporthash_create *req =
-	    (struct ip_set_req_ipporthash_create *) data;
-	struct ip_set_ipporthash *map;
-	uint16_t i;
-
-	if (size != sizeof(struct ip_set_req_ipporthash_create)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			       sizeof(struct ip_set_req_ipporthash_create),
-			       size);
-		return -EINVAL;
-	}
-
-	if (req->hashsize < 1) {
-		ip_set_printk("hashsize too small");
-		return -ENOEXEC;
-	}
-
-	if (req->probes < 1) {
-		ip_set_printk("probes too small");
-		return -ENOEXEC;
-	}
-
-	map = kmalloc(sizeof(struct ip_set_ipporthash) 
-		      + req->probes * sizeof(uint32_t), GFP_KERNEL);
-	if (!map) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_set_ipporthash)
-		   + req->probes * sizeof(uint32_t));
-		return -ENOMEM;
-	}
-	for (i = 0; i < req->probes; i++)
-		get_random_bytes(((uint32_t *) map->initval)+i, 4);
-	map->hashsize = req->hashsize;
-	map->probes = req->probes;
-	map->resize = req->resize;
-	map->first_ip = req->from;
-	map->last_ip = req->to;
-	map->members = harray_malloc(map->hashsize, sizeof(ip_set_ip_t), GFP_KERNEL);
-	if (!map->members) {
-		DP("out of memory for %d bytes", map->hashsize * sizeof(ip_set_ip_t));
-		kfree(map);
-		return -ENOMEM;
-	}
-
-	set->data = map;
-	return 0;
-}
-
-static void destroy(struct ip_set *set)
-{
-	struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
-
-	harray_free(map->members);
-	kfree(map);
-
-	set->data = NULL;
-}
-
-static void flush(struct ip_set *set)
-{
-	struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
-	harray_flush(map->members, map->hashsize, sizeof(ip_set_ip_t));
-}
-
-static void list_header(const struct ip_set *set, void *data)
-{
-	struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
-	struct ip_set_req_ipporthash_create *header =
-	    (struct ip_set_req_ipporthash_create *) data;
-
-	header->hashsize = map->hashsize;
-	header->probes = map->probes;
-	header->resize = map->resize;
-	header->from = map->first_ip;
-	header->to = map->last_ip;
-}
-
-static int list_members_size(const struct ip_set *set)
-{
-	struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
-
-	return (map->hashsize * sizeof(ip_set_ip_t));
-}
-
-static void list_members(const struct ip_set *set, void *data)
-{
-	struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
-	ip_set_ip_t i, *elem;
-
-	for (i = 0; i < map->hashsize; i++) {
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);	
-		((ip_set_ip_t *)data)[i] = *elem;
-	}
-}
-
-static struct ip_set_type ip_set_ipporthash = {
-	.typename		= SETTYPE_NAME,
-	.features		= IPSET_TYPE_IP | IPSET_TYPE_PORT | IPSET_DATA_DOUBLE,
-	.protocol_version	= IP_SET_PROTOCOL_VERSION,
-	.create			= &create,
-	.destroy		= &destroy,
-	.flush			= &flush,
-	.reqsize		= sizeof(struct ip_set_req_ipporthash),
-	.addip			= &addip,
-	.addip_kernel		= &addip_kernel,
-	.retry			= &retry,
-	.delip			= &delip,
-	.delip_kernel		= &delip_kernel,
-	.testip			= &testip,
-	.testip_kernel		= &testip_kernel,
-	.header_size		= sizeof(struct ip_set_req_ipporthash_create),
-	.list_header		= &list_header,
-	.list_members_size	= &list_members_size,
-	.list_members		= &list_members,
-	.me			= THIS_MODULE,
-};
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
-MODULE_DESCRIPTION("ipporthash type of IP sets");
-
-static int __init init(void)
-{
-	return ip_set_register_set_type(&ip_set_ipporthash);
-}
-
-static void __exit fini(void)
-{
-	/* FIXME: possible race with ip_set_create() */
-	ip_set_unregister_set_type(&ip_set_ipporthash);
-}
-
-module_init(init);
-module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_iptree.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_iptree.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_iptree.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_iptree.c	1970-01-01 01:00:00.000000000 +0100
@@ -1,544 +0,0 @@
-/* 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/netfilter_ipv4/ip_tables.h>
-#include <linux/netfilter_ipv4/ip_set.h>
-#include <linux/errno.h>
-#include <asm/uaccess.h>
-#include <asm/bitops.h>
-#include <linux/spinlock.h>
-
-/* Backward compatibility */
-#ifndef __nocast
-#define __nocast
-#endif
-
-#include <linux/netfilter_ipv4/ip_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 kmem_cache_t *branch_cachep;
-static kmem_cache_t *leaf_cachep;
-
-#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 ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
-	struct ip_set_iptreeb *btree;
-	struct ip_set_iptreec *ctree;
-	struct ip_set_iptreed *dtree;
-	unsigned char a,b,c,d;
-	
-	*hash_ip = ip;
-	ABCD(a, b, c, d, hash_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 ip_set *set, const void *data, size_t size,
-       ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_iptree *req = 
-	    (struct ip_set_req_iptree *) data;
-
-	if (size != sizeof(struct ip_set_req_iptree)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_iptree),
-			      size);
-		return -EINVAL;
-	}
-	return __testip(set, req->ip, hash_ip);
-}
-
-static int
-testip_kernel(struct ip_set *set, 
-	      const struct sk_buff *skb,
-	      ip_set_ip_t *hash_ip,
-	      const u_int32_t *flags,
-	      unsigned char index)
-{
-	int res;
-	
-	DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u",
-	   flags[index] & IPSET_SRC ? "SRC" : "DST",
-	   NIPQUAD(skb->nh.iph->saddr),
-	   NIPQUAD(skb->nh.iph->daddr));
-
-	res =  __testip(set,
-			ntohl(flags[index] & IPSET_SRC 
-				? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-			hash_ip);
-	return (res < 0 ? 0 : res);
-}
-
-#define ADDIP_WALK(map, elem, branch, type, cachep, flags) do {	\
-	if ((map)->tree[elem]) {				\
-		DP("found %u", elem);				\
-		branch = (map)->tree[elem];			\
-	} else {						\
-		branch = (type *)				\
-			kmem_cache_alloc(cachep, 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 ip_set *set, ip_set_ip_t ip, unsigned int timeout,
-	ip_set_ip_t *hash_ip,
-	unsigned int __nocast flags)
-{
-	struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
-	struct ip_set_iptreeb *btree;
-	struct ip_set_iptreec *ctree;
-	struct ip_set_iptreed *dtree;
-	unsigned char a,b,c,d;
-	int ret = 0;
-	
-	*hash_ip = ip;
-	ABCD(a, b, c, d, hash_ip);
-	DP("%u %u %u %u timeout %u", a, b, c, d, timeout);
-	ADDIP_WALK(map, a, btree, struct ip_set_iptreeb, branch_cachep, flags);
-	ADDIP_WALK(btree, b, ctree, struct ip_set_iptreec, branch_cachep, flags);
-	ADDIP_WALK(ctree, c, dtree, struct ip_set_iptreed, leaf_cachep, 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 ip_set *set, const void *data, size_t size,
-      ip_set_ip_t *hash_ip)
-{
-	struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
-	struct ip_set_req_iptree *req = 
-		(struct ip_set_req_iptree *) data;
-
-	if (size != sizeof(struct ip_set_req_iptree)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_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,
-		       hash_ip,
-		       GFP_ATOMIC);
-}
-
-static int
-addip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
-
-	return __addip(set,
-		       ntohl(flags[index] & IPSET_SRC 
-		       		? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-		       map->timeout,
-		       hash_ip,
-		       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 ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
-	struct ip_set_iptreeb *btree;
-	struct ip_set_iptreec *ctree;
-	struct ip_set_iptreed *dtree;
-	unsigned char a,b,c,d;
-	
-	*hash_ip = ip;
-	ABCD(a, b, c, d, hash_ip);
-	DELIP_WALK(map, a, btree);
-	DELIP_WALK(btree, b, ctree);
-	DELIP_WALK(ctree, c, dtree);
-
-	if (dtree->expires[d]) {
-		dtree->expires[d] = 0;
-		return 0;
-	}
-	return -EEXIST;
-}
-
-static int
-delip(struct ip_set *set, const void *data, size_t size,
-      ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_iptree *req =
-	    (struct ip_set_req_iptree *) data;
-
-	if (size != sizeof(struct ip_set_req_iptree)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_iptree),
-			      size);
-		return -EINVAL;
-	}
-	return __delip(set, req->ip, hash_ip);
-}
-
-static int
-delip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	return __delip(set,
-		       ntohl(flags[index] & IPSET_SRC 
-		       		? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-		       hash_ip);
-}
-
-#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 ip_tree_gc(unsigned long ul_set)
-{
-	struct ip_set *set = (void *) ul_set;
-	struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
-	struct ip_set_iptreeb *btree;
-	struct ip_set_iptreec *ctree;
-	struct ip_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;
-			else
-				k = 1;
-		}
-	}
-	if (k == 0) {
-		DP("gc: %s: leaf %u %u %u empty",
-		    set->name, a, b, c);
-		kmem_cache_free(leaf_cachep, 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);
-		kmem_cache_free(branch_cachep, 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);
-		kmem_cache_free(branch_cachep, 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 ip_set *set)
-{
-	struct ip_set_iptree *map = (struct ip_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 = ip_tree_gc;
-	map->gc.expires = jiffies + map->gc_interval * HZ;
-	add_timer(&map->gc);
-}
-
-static int create(struct ip_set *set, const void *data, size_t size)
-{
-	struct ip_set_req_iptree_create *req =
-	    (struct ip_set_req_iptree_create *) data;
-	struct ip_set_iptree *map;
-
-	if (size != sizeof(struct ip_set_req_iptree_create)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_iptree_create),
-			      size);
-		return -EINVAL;
-	}
-
-	map = kmalloc(sizeof(struct ip_set_iptree), GFP_KERNEL);
-	if (!map) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_set_iptree));
-		return -ENOMEM;
-	}
-	memset(map, 0, sizeof(*map));
-	map->timeout = req->timeout;
-	set->data = map;
-
-	init_gc_timer(set);
-
-	return 0;
-}
-
-static void __flush(struct ip_set_iptree *map)
-{
-	struct ip_set_iptreeb *btree;
-	struct ip_set_iptreec *ctree;
-	struct ip_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);
-	kmem_cache_free(leaf_cachep, dtree);
-	LOOP_WALK_END;
-	kmem_cache_free(branch_cachep, ctree);
-	LOOP_WALK_END;
-	kmem_cache_free(branch_cachep, btree);
-	LOOP_WALK_END;
-}
-
-static void destroy(struct ip_set *set)
-{
-	struct ip_set_iptree *map = (struct ip_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 ip_set *set)
-{
-	struct ip_set_iptree *map = (struct ip_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 ip_set *set, void *data)
-{
-	struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
-	struct ip_set_req_iptree_create *header =
-	    (struct ip_set_req_iptree_create *) data;
-
-	header->timeout = map->timeout;
-}
-
-static int list_members_size(const struct ip_set *set)
-{
-	struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
-	struct ip_set_iptreeb *btree;
-	struct ip_set_iptreec *ctree;
-	struct ip_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 ip_set_req_iptree));
-}
-
-static void list_members(const struct ip_set *set, void *data)
-{
-	struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
-	struct ip_set_iptreeb *btree;
-	struct ip_set_iptreec *ctree;
-	struct ip_set_iptreed *dtree;
-	unsigned int a,b,c,d;
-	size_t offset = 0;
-	struct ip_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 ip_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 ip_set_req_iptree);
-		}
-	}
-	LOOP_WALK_END;
-	LOOP_WALK_END;
-	LOOP_WALK_END;
-}
-
-static struct ip_set_type ip_set_iptree = {
-	.typename		= SETTYPE_NAME,
-	.features		= IPSET_TYPE_IP | IPSET_DATA_SINGLE,
-	.protocol_version	= IP_SET_PROTOCOL_VERSION,
-	.create			= &create,
-	.destroy		= &destroy,
-	.flush			= &flush,
-	.reqsize		= sizeof(struct ip_set_req_iptree),
-	.addip			= &addip,
-	.addip_kernel		= &addip_kernel,
-	.delip			= &delip,
-	.delip_kernel		= &delip_kernel,
-	.testip			= &testip,
-	.testip_kernel		= &testip_kernel,
-	.header_size		= sizeof(struct ip_set_req_iptree_create),
-	.list_header		= &list_header,
-	.list_members_size	= &list_members_size,
-	.list_members		= &list_members,
-	.me			= THIS_MODULE,
-};
-
-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;
-	
-	branch_cachep = kmem_cache_create("ip_set_iptreeb",
-				sizeof(struct ip_set_iptreeb),
-				0, 0, NULL, NULL);
-	if (!branch_cachep) {
-		printk(KERN_ERR "Unable to create ip_set_iptreeb slab cache\n");
-		ret = -ENOMEM;
-		goto out;
-	}
-	leaf_cachep = kmem_cache_create("ip_set_iptreed",
-				sizeof(struct ip_set_iptreed),
-				0, 0, NULL, NULL);
-	if (!leaf_cachep) {
-		printk(KERN_ERR "Unable to create ip_set_iptreed slab cache\n");
-		ret = -ENOMEM;
-		goto free_branch;
-	}
-	ret = ip_set_register_set_type(&ip_set_iptree);
-	if (ret == 0)
-		goto out;
-
-	kmem_cache_destroy(leaf_cachep);
-    free_branch:	
-	kmem_cache_destroy(branch_cachep);
-    out:
-	return ret;
-}
-
-static void __exit fini(void)
-{
-	/* FIXME: possible race with ip_set_create() */
-	ip_set_unregister_set_type(&ip_set_iptree);
-	kmem_cache_destroy(leaf_cachep);
-	kmem_cache_destroy(branch_cachep);
-}
-
-module_init(init);
-module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_macipmap.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_macipmap.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_macipmap.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_macipmap.c	1970-01-01 01:00:00.000000000 +0100
@@ -1,353 +0,0 @@
-/* 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/netfilter_ipv4/ip_tables.h>
-#include <linux/netfilter_ipv4/ip_set.h>
-#include <linux/errno.h>
-#include <asm/uaccess.h>
-#include <asm/bitops.h>
-#include <linux/spinlock.h>
-#include <linux/if_ether.h>
-#include <linux/vmalloc.h>
-
-#include <linux/netfilter_ipv4/ip_set_malloc.h>
-#include <linux/netfilter_ipv4/ip_set_macipmap.h>
-
-static int
-testip(struct ip_set *set, const void *data, size_t size, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_macipmap *map = (struct ip_set_macipmap *) set->data;
-	struct ip_set_macip *table = (struct ip_set_macip *) map->members;	
-	struct ip_set_req_macipmap *req = (struct ip_set_req_macipmap *) data;
-
-	if (size != sizeof(struct ip_set_req_macipmap)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_macipmap),
-			      size);
-		return -EINVAL;
-	}
-
-	if (req->ip < map->first_ip || req->ip > map->last_ip)
-		return -ERANGE;
-
-	*hash_ip = req->ip;
-	DP("set: %s, ip:%u.%u.%u.%u, %u.%u.%u.%u",
-	   set->name, HIPQUAD(req->ip), HIPQUAD(*hash_ip));		
-	if (test_bit(IPSET_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 & IPSET_MACIP_MATCHUNSET ? 1 : 0);
-	}
-}
-
-static int
-testip_kernel(struct ip_set *set, 
-	      const struct sk_buff *skb,
-	      ip_set_ip_t *hash_ip,
-	      const u_int32_t *flags,
-	      unsigned char index)
-{
-	struct ip_set_macipmap *map =
-	    (struct ip_set_macipmap *) set->data;
-	struct ip_set_macip *table =
-	    (struct ip_set_macip *) map->members;
-	ip_set_ip_t ip;
-	
-	ip = ntohl(flags[index] & IPSET_SRC
-			? skb->nh.iph->saddr
-			: skb->nh.iph->daddr);
-	DP("flag: %s src: %u.%u.%u.%u dst: %u.%u.%u.%u",
-	   flags[index] & IPSET_SRC ? "SRC" : "DST",
-	   NIPQUAD(skb->nh.iph->saddr),
-	   NIPQUAD(skb->nh.iph->daddr));
-
-	if (ip < map->first_ip || ip > map->last_ip)
-		return 0;
-
-	*hash_ip = ip;	
-	DP("set: %s, ip:%u.%u.%u.%u, %u.%u.%u.%u",
-	   set->name, HIPQUAD(ip), HIPQUAD(*hash_ip));		
-	if (test_bit(IPSET_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 & IPSET_MACIP_MATCHUNSET ? 1 : 0);
-	}
-}
-
-/* returns 0 on success */
-static inline int
-__addip(struct ip_set *set, 
-	ip_set_ip_t ip, unsigned char *ethernet, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_macipmap *map =
-	    (struct ip_set_macipmap *) set->data;
-	struct ip_set_macip *table =
-	    (struct ip_set_macip *) map->members;
-
-	if (ip < map->first_ip || ip > map->last_ip)
-		return -ERANGE;
-	if (test_and_set_bit(IPSET_MACIP_ISSET, 
-			     (void *) &table[ip - map->first_ip].flags))
-		return -EEXIST;
-
-	*hash_ip = ip;
-	DP("%u.%u.%u.%u, %u.%u.%u.%u", HIPQUAD(ip), HIPQUAD(*hash_ip));
-	memcpy(&table[ip - map->first_ip].ethernet, ethernet, ETH_ALEN);
-	return 0;
-}
-
-static int
-addip(struct ip_set *set, const void *data, size_t size,
-      ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_macipmap *req =
-	    (struct ip_set_req_macipmap *) data;
-
-	if (size != sizeof(struct ip_set_req_macipmap)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_macipmap),
-			      size);
-		return -EINVAL;
-	}
-	return __addip(set, req->ip, req->ethernet, hash_ip);
-}
-
-static int
-addip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	ip_set_ip_t ip;
-	
-	ip = ntohl(flags[index] & IPSET_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, hash_ip);
-}
-
-static inline int
-__delip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_macipmap *map =
-	    (struct ip_set_macipmap *) set->data;
-	struct ip_set_macip *table =
-	    (struct ip_set_macip *) map->members;
-
-	if (ip < map->first_ip || ip > map->last_ip)
-		return -ERANGE;
-	if (!test_and_clear_bit(IPSET_MACIP_ISSET, 
-				(void *)&table[ip - map->first_ip].flags))
-		return -EEXIST;
-
-	*hash_ip = ip;
-	DP("%u.%u.%u.%u, %u.%u.%u.%u", HIPQUAD(ip), HIPQUAD(*hash_ip));
-	return 0;
-}
-
-static int
-delip(struct ip_set *set, const void *data, size_t size,
-     ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_macipmap *req =
-	    (struct ip_set_req_macipmap *) data;
-
-	if (size != sizeof(struct ip_set_req_macipmap)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_macipmap),
-			      size);
-		return -EINVAL;
-	}
-	return __delip(set, req->ip, hash_ip);
-}
-
-static int
-delip_kernel(struct ip_set *set,
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	return __delip(set,
-		       ntohl(flags[index] & IPSET_SRC 
-		       		? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-		       hash_ip);
-}
-
-static inline size_t members_size(ip_set_id_t from, ip_set_id_t to)
-{
-	return (size_t)((to - from + 1) * sizeof(struct ip_set_macip));
-}
-
-static int create(struct ip_set *set, const void *data, size_t size)
-{
-	int newbytes;
-	struct ip_set_req_macipmap_create *req =
-	    (struct ip_set_req_macipmap_create *) data;
-	struct ip_set_macipmap *map;
-
-	if (size != sizeof(struct ip_set_req_macipmap_create)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_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) {
-		ip_set_printk("range too big (max %d addresses)",
-			       MAX_RANGE+1);
-		return -ENOEXEC;
-	}
-
-	map = kmalloc(sizeof(struct ip_set_macipmap), GFP_KERNEL);
-	if (!map) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_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 = ip_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 ip_set *set)
-{
-	struct ip_set_macipmap *map =
-	    (struct ip_set_macipmap *) set->data;
-
-	ip_set_free(map->members, members_size(map->first_ip, map->last_ip));
-	kfree(map);
-
-	set->data = NULL;
-}
-
-static void flush(struct ip_set *set)
-{
-	struct ip_set_macipmap *map =
-	    (struct ip_set_macipmap *) set->data;
-	memset(map->members, 0, members_size(map->first_ip, map->last_ip));
-}
-
-static void list_header(const struct ip_set *set, void *data)
-{
-	struct ip_set_macipmap *map =
-	    (struct ip_set_macipmap *) set->data;
-	struct ip_set_req_macipmap_create *header =
-	    (struct ip_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 ip_set *set)
-{
-	struct ip_set_macipmap *map =
-	    (struct ip_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 ip_set *set, void *data)
-{
-	struct ip_set_macipmap *map =
-	    (struct ip_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 ip_set_type ip_set_macipmap = {
-	.typename		= SETTYPE_NAME,
-	.features		= IPSET_TYPE_IP | IPSET_DATA_SINGLE,
-	.protocol_version	= IP_SET_PROTOCOL_VERSION,
-	.create			= &create,
-	.destroy		= &destroy,
-	.flush			= &flush,
-	.reqsize		= sizeof(struct ip_set_req_macipmap),
-	.addip			= &addip,
-	.addip_kernel		= &addip_kernel,
-	.delip			= &delip,
-	.delip_kernel		= &delip_kernel,
-	.testip			= &testip,
-	.testip_kernel		= &testip_kernel,
-	.header_size		= sizeof(struct ip_set_req_macipmap_create),
-	.list_header		= &list_header,
-	.list_members_size	= &list_members_size,
-	.list_members		= &list_members,
-	.me			= THIS_MODULE,
-};
-
-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 ip_set_register_set_type(&ip_set_macipmap);
-}
-
-static void __exit fini(void)
-{
-	/* FIXME: possible race with ip_set_create() */
-	ip_set_unregister_set_type(&ip_set_macipmap);
-}
-
-module_init(init);
-module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_nethash.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_nethash.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_nethash.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_nethash.c	1970-01-01 01:00:00.000000000 +0100
@@ -1,466 +0,0 @@
-/* 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/netfilter_ipv4/ip_tables.h>
-#include <linux/netfilter_ipv4/ip_set.h>
-#include <linux/errno.h>
-#include <asm/uaccess.h>
-#include <asm/bitops.h>
-#include <linux/spinlock.h>
-#include <linux/vmalloc.h>
-#include <linux/random.h>
-
-#include <net/ip.h>
-
-#include <linux/netfilter_ipv4/ip_set_malloc.h>
-#include <linux/netfilter_ipv4/ip_set_nethash.h>
-#include <linux/netfilter_ipv4/ip_set_jhash.h>
-
-static inline __u32
-jhash_ip(const struct ip_set_nethash *map, uint16_t i, ip_set_ip_t ip)
-{
-	return jhash_1word(ip, *(((uint32_t *) map->initval) + i));
-}
-
-static inline __u32
-hash_id_cidr(struct ip_set_nethash *map,
-	     ip_set_ip_t ip,
-	     unsigned char cidr,
-	     ip_set_ip_t *hash_ip)
-{
-	__u32 id;
-	u_int16_t i;
-	ip_set_ip_t *elem;
-
-	*hash_ip = pack(ip, cidr);
-	
-	for (i = 0; i < map->probes; i++) {
-		id = jhash_ip(map, i, *hash_ip) % map->hashsize;
-	   	DP("hash key: %u", id);
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id);
-	   	if (*elem == *hash_ip)
-			return id;
-	}
-	return UINT_MAX;
-}
-
-static inline __u32
-hash_id(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-	__u32 id = UINT_MAX;
-	int i;
-
-	for (i = 0; i < 30 && map->cidr[i]; i++) {
-		id = hash_id_cidr(map, ip, map->cidr[i], hash_ip);
-		if (id != UINT_MAX)
-			break;
-	}
-	return id;
-}
-
-static inline int
-__testip_cidr(struct ip_set *set, ip_set_ip_t ip, unsigned char cidr,
-	      ip_set_ip_t *hash_ip)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-
-	return (hash_id_cidr(map, ip, cidr, hash_ip) != UINT_MAX);
-}
-
-static inline int
-__testip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
-{
-	return (hash_id(set, ip, hash_ip) != UINT_MAX);
-}
-
-static int
-testip(struct ip_set *set, const void *data, size_t size,
-       ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_nethash *req = 
-	    (struct ip_set_req_nethash *) data;
-
-	if (size != sizeof(struct ip_set_req_nethash)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_nethash),
-			      size);
-		return -EINVAL;
-	}
-	return (req->cidr == 32 ? __testip(set, req->ip, hash_ip)
-		: __testip_cidr(set, req->ip, req->cidr, hash_ip));
-}
-
-static int
-testip_kernel(struct ip_set *set, 
-	      const struct sk_buff *skb,
-	      ip_set_ip_t *hash_ip,
-	      const u_int32_t *flags,
-	      unsigned char index)
-{
-	return __testip(set,
-			ntohl(flags[index] & IPSET_SRC 
-				? skb->nh.iph->saddr 
-				: skb->nh.iph->daddr),
-			hash_ip);
-}
-
-static inline int
-__addip_base(struct ip_set_nethash *map, ip_set_ip_t ip)
-{
-	__u32 probe;
-	u_int16_t i;
-	ip_set_ip_t *elem;
-	
-	for (i = 0; i < map->probes; i++) {
-		probe = jhash_ip(map, i, ip) % map->hashsize;
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, probe);
-		if (*elem == ip)
-			return -EEXIST;
-		if (!*elem) {
-			*elem = ip;
-			return 0;
-		}
-	}
-	/* Trigger rehashing */
-	return -EAGAIN;
-}
-
-static inline int
-__addip(struct ip_set_nethash *map, ip_set_ip_t ip, unsigned char cidr,
-	ip_set_ip_t *hash_ip)
-{
-	*hash_ip = pack(ip, cidr);
-	DP("%u.%u.%u.%u/%u, %u.%u.%u.%u", HIPQUAD(ip), cidr, HIPQUAD(*hash_ip));
-	
-	return __addip_base(map, *hash_ip);
-}
-
-static void
-update_cidr_sizes(struct ip_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 ip_set *set, const void *data, size_t size,
-        ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_nethash *req = 
-	    (struct ip_set_req_nethash *) data;
-	int ret;
-
-	if (size != sizeof(struct ip_set_req_nethash)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_nethash),
-			      size);
-		return -EINVAL;
-	}
-	ret = __addip((struct ip_set_nethash *) set->data, 
-		      req->ip, req->cidr, hash_ip);
-	
-	if (ret == 0)
-		update_cidr_sizes((struct ip_set_nethash *) set->data,
-				  req->cidr);
-	
-	return ret;
-}
-
-static int
-addip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-	int ret = -ERANGE;
-	ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC 
-					? skb->nh.iph->saddr
-					: skb->nh.iph->daddr);
-	
-	if (map->cidr[0])
-		ret = __addip(map, ip, map->cidr[0], hash_ip);
-		
-	return ret;
-}
-
-static int retry(struct ip_set *set)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-	ip_set_ip_t *elem;
-	void *members;
-	u_int32_t i, hashsize = map->hashsize;
-	int res;
-	struct ip_set_nethash *tmp;
-	
-	if (map->resize == 0)
-		return -ERANGE;
-
-    again:
-    	res = 0;
-    	
-	/* Calculate new parameters */
-	hashsize += (hashsize * map->resize)/100;
-	if (hashsize == map->hashsize)
-		hashsize++;
-	
-	ip_set_printk("rehashing of set %s triggered: "
-		      "hashsize grows from %u to %u",
-		      set->name, map->hashsize, hashsize);
-
-	tmp = kmalloc(sizeof(struct ip_set_nethash) 
-		      + map->probes * sizeof(uint32_t), GFP_ATOMIC);
-	if (!tmp) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_set_nethash)
-		   + map->probes * sizeof(uint32_t));
-		return -ENOMEM;
-	}
-	tmp->members = harray_malloc(hashsize, sizeof(ip_set_ip_t), GFP_ATOMIC);
-	if (!tmp->members) {
-		DP("out of memory for %d bytes", hashsize * sizeof(ip_set_ip_t));
-		kfree(tmp);
-		return -ENOMEM;
-	}
-	tmp->hashsize = hashsize;
-	tmp->probes = map->probes;
-	tmp->resize = map->resize;
-	memcpy(tmp->initval, map->initval, map->probes * sizeof(uint32_t));
-	memcpy(tmp->cidr, map->cidr, 30 * sizeof(unsigned char));
-	
-	write_lock_bh(&set->lock);
-	map = (struct ip_set_nethash *) set->data; /* Play safe */
-	for (i = 0; i < map->hashsize && res == 0; i++) {
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);	
-		if (*elem)
-			res = __addip_base(tmp, *elem);
-	}
-	if (res) {
-		/* Failure, try again */
-		write_unlock_bh(&set->lock);
-		harray_free(tmp->members);
-		kfree(tmp);
-		goto again;
-	}
-	
-	/* Success at resizing! */
-	members = map->members;
-	
-	map->hashsize = tmp->hashsize;
-	map->members = tmp->members;
-	write_unlock_bh(&set->lock);
-
-	harray_free(members);
-	kfree(tmp);
-
-	return 0;
-}
-
-static inline int
-__delip(struct ip_set_nethash *map, ip_set_ip_t ip, unsigned char cidr,
-	ip_set_ip_t *hash_ip)
-{
-	ip_set_ip_t id = hash_id_cidr(map, ip, cidr, hash_ip);
-	ip_set_ip_t *elem;
-
-	if (id == UINT_MAX)
-		return -EEXIST;
-		
-	elem = HARRAY_ELEM(map->members, ip_set_ip_t *, id);
-	*elem = 0;
-	return 0;
-}
-
-static int
-delip(struct ip_set *set, const void *data, size_t size,
-        ip_set_ip_t *hash_ip)
-{
-	struct ip_set_req_nethash *req =
-	    (struct ip_set_req_nethash *) data;
-
-	if (size != sizeof(struct ip_set_req_nethash)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_nethash),
-			      size);
-		return -EINVAL;
-	}
-	/* TODO: no garbage collection in map->cidr */		
-	return __delip((struct ip_set_nethash *) set->data, 
-		       req->ip, req->cidr, hash_ip);
-}
-
-static int
-delip_kernel(struct ip_set *set, 
-	     const struct sk_buff *skb,
-	     ip_set_ip_t *hash_ip,
-	     const u_int32_t *flags,
-	     unsigned char index)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-	int ret = -ERANGE;
-	ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC 
-					? skb->nh.iph->saddr
-					: skb->nh.iph->daddr);
-	
-	if (map->cidr[0])
-		ret = __delip(map, ip, map->cidr[0], hash_ip);
-	
-	return ret;
-}
-
-static int create(struct ip_set *set, const void *data, size_t size)
-{
-	struct ip_set_req_nethash_create *req =
-	    (struct ip_set_req_nethash_create *) data;
-	struct ip_set_nethash *map;
-	uint16_t i;
-
-	if (size != sizeof(struct ip_set_req_nethash_create)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			       sizeof(struct ip_set_req_nethash_create),
-			       size);
-		return -EINVAL;
-	}
-
-	if (req->hashsize < 1) {
-		ip_set_printk("hashsize too small");
-		return -ENOEXEC;
-	}
-	if (req->probes < 1) {
-		ip_set_printk("probes too small");
-		return -ENOEXEC;
-	}
-
-	map = kmalloc(sizeof(struct ip_set_nethash)
-		      + req->probes * sizeof(uint32_t), GFP_KERNEL);
-	if (!map) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_set_nethash)
-		   + req->probes * sizeof(uint32_t));
-		return -ENOMEM;
-	}
-	for (i = 0; i < req->probes; i++)
-		get_random_bytes(((uint32_t *) map->initval)+i, 4);
-	map->hashsize = req->hashsize;
-	map->probes = req->probes;
-	map->resize = req->resize;
-	memset(map->cidr, 0, 30 * sizeof(unsigned char));
-	map->members = harray_malloc(map->hashsize, sizeof(ip_set_ip_t), GFP_KERNEL);
-	if (!map->members) {
-		DP("out of memory for %d bytes", map->hashsize * sizeof(ip_set_ip_t));
-		kfree(map);
-		return -ENOMEM;
-	}
-	
-	set->data = map;
-	return 0;
-}
-
-static void destroy(struct ip_set *set)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-
-	harray_free(map->members);
-	kfree(map);
-
-	set->data = NULL;
-}
-
-static void flush(struct ip_set *set)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-	harray_flush(map->members, map->hashsize, sizeof(ip_set_ip_t));
-	memset(map->cidr, 0, 30 * sizeof(unsigned char));
-}
-
-static void list_header(const struct ip_set *set, void *data)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-	struct ip_set_req_nethash_create *header =
-	    (struct ip_set_req_nethash_create *) data;
-
-	header->hashsize = map->hashsize;
-	header->probes = map->probes;
-	header->resize = map->resize;
-}
-
-static int list_members_size(const struct ip_set *set)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-
-	return (map->hashsize * sizeof(ip_set_ip_t));
-}
-
-static void list_members(const struct ip_set *set, void *data)
-{
-	struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
-	ip_set_ip_t i, *elem;
-
-	for (i = 0; i < map->hashsize; i++) {
-		elem = HARRAY_ELEM(map->members, ip_set_ip_t *, i);	
-		((ip_set_ip_t *)data)[i] = *elem;
-	}
-}
-
-static struct ip_set_type ip_set_nethash = {
-	.typename		= SETTYPE_NAME,
-	.features		= IPSET_TYPE_IP | IPSET_DATA_SINGLE,
-	.protocol_version	= IP_SET_PROTOCOL_VERSION,
-	.create			= &create,
-	.destroy		= &destroy,
-	.flush			= &flush,
-	.reqsize		= sizeof(struct ip_set_req_nethash),
-	.addip			= &addip,
-	.addip_kernel		= &addip_kernel,
-	.retry			= &retry,
-	.delip			= &delip,
-	.delip_kernel		= &delip_kernel,
-	.testip			= &testip,
-	.testip_kernel		= &testip_kernel,
-	.header_size		= sizeof(struct ip_set_req_nethash_create),
-	.list_header		= &list_header,
-	.list_members_size	= &list_members_size,
-	.list_members		= &list_members,
-	.me			= THIS_MODULE,
-};
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
-MODULE_DESCRIPTION("nethash type of IP sets");
-
-static int __init init(void)
-{
-	return ip_set_register_set_type(&ip_set_nethash);
-}
-
-static void __exit fini(void)
-{
-	/* FIXME: possible race with ip_set_create() */
-	ip_set_unregister_set_type(&ip_set_nethash);
-}
-
-module_init(init);
-module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_portmap.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_portmap.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ip_set_portmap.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ip_set_portmap.c	1970-01-01 01:00:00.000000000 +0100
@@ -1,334 +0,0 @@
-/* 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/netfilter_ipv4/ip_tables.h>
-#include <linux/netfilter_ipv4/ip_set.h>
-#include <linux/errno.h>
-#include <asm/uaccess.h>
-#include <asm/bitops.h>
-#include <linux/spinlock.h>
-
-#include <net/ip.h>
-
-#include <linux/netfilter_ipv4/ip_set_portmap.h>
-
-/* We must handle non-linear skbs */
-static inline ip_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 & IPSET_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 & IPSET_SRC ?
-			     udph.source : udph.dest);
-	    }
-	default:
-		return INVALID_PORT;
-	}
-}
-
-static inline int
-__testport(struct ip_set *set, ip_set_ip_t port, ip_set_ip_t *hash_port)
-{
-	struct ip_set_portmap *map = (struct ip_set_portmap *) set->data;
-
-	if (port < map->first_port || port > map->last_port)
-		return -ERANGE;
-		
-	*hash_port = port;
-	DP("set: %s, port:%u, %u", set->name, port, *hash_port);
-	return !!test_bit(port - map->first_port, map->members);
-}
-
-static int
-testport(struct ip_set *set, const void *data, size_t size,
-         ip_set_ip_t *hash_port)
-{
-	struct ip_set_req_portmap *req = 
-	    (struct ip_set_req_portmap *) data;
-
-	if (size != sizeof(struct ip_set_req_portmap)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_portmap),
-			      size);
-		return -EINVAL;
-	}
-	return __testport(set, req->port, hash_port);
-}
-
-static int
-testport_kernel(struct ip_set *set, 
-	        const struct sk_buff *skb,
-	        ip_set_ip_t *hash_port,
-	        const u_int32_t *flags,
-	        unsigned char index)
-{
-	int res;
-	ip_set_ip_t port = get_port(skb, flags[index]);
-
-	DP("flag %s port %u", flags[index] & IPSET_SRC ? "SRC" : "DST", port);	
-	if (port == INVALID_PORT)
-		return 0;	
-
-	res =  __testport(set, port, hash_port);
-	
-	return (res < 0 ? 0 : res);
-}
-
-static inline int
-__addport(struct ip_set *set, ip_set_ip_t port, ip_set_ip_t *hash_port)
-{
-	struct ip_set_portmap *map = (struct ip_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;
-		
-	*hash_port = port;
-	DP("port %u", port);
-	return 0;
-}
-
-static int
-addport(struct ip_set *set, const void *data, size_t size,
-        ip_set_ip_t *hash_port)
-{
-	struct ip_set_req_portmap *req = 
-	    (struct ip_set_req_portmap *) data;
-
-	if (size != sizeof(struct ip_set_req_portmap)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_portmap),
-			      size);
-		return -EINVAL;
-	}
-	return __addport(set, req->port, hash_port);
-}
-
-static int
-addport_kernel(struct ip_set *set, 
-	       const struct sk_buff *skb,
-	       ip_set_ip_t *hash_port,
-	       const u_int32_t *flags,
-	       unsigned char index)
-{
-	ip_set_ip_t port = get_port(skb, flags[index]);
-	
-	if (port == INVALID_PORT)
-		return -EINVAL;
-
-	return __addport(set, port, hash_port);
-}
-
-static inline int
-__delport(struct ip_set *set, ip_set_ip_t port, ip_set_ip_t *hash_port)
-{
-	struct ip_set_portmap *map = (struct ip_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;
-		
-	*hash_port = port;
-	DP("port %u", port);
-	return 0;
-}
-
-static int
-delport(struct ip_set *set, const void *data, size_t size,
-        ip_set_ip_t *hash_port)
-{
-	struct ip_set_req_portmap *req =
-	    (struct ip_set_req_portmap *) data;
-
-	if (size != sizeof(struct ip_set_req_portmap)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			      sizeof(struct ip_set_req_portmap),
-			      size);
-		return -EINVAL;
-	}
-	return __delport(set, req->port, hash_port);
-}
-
-static int
-delport_kernel(struct ip_set *set, 
-	       const struct sk_buff *skb,
-	       ip_set_ip_t *hash_port,
-	       const u_int32_t *flags,
-	       unsigned char index)
-{
-	ip_set_ip_t port = get_port(skb, flags[index]);
-	
-	if (port == INVALID_PORT)
-		return -EINVAL;
-
-	return __delport(set, port, hash_port);
-}
-
-static int create(struct ip_set *set, const void *data, size_t size)
-{
-	int newbytes;
-	struct ip_set_req_portmap_create *req =
-	    (struct ip_set_req_portmap_create *) data;
-	struct ip_set_portmap *map;
-
-	if (size != sizeof(struct ip_set_req_portmap_create)) {
-		ip_set_printk("data length wrong (want %zu, have %zu)",
-			       sizeof(struct ip_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) {
-		ip_set_printk("range too big (max %d ports)",
-			       MAX_RANGE+1);
-		return -ENOEXEC;
-	}
-
-	map = kmalloc(sizeof(struct ip_set_portmap), GFP_KERNEL);
-	if (!map) {
-		DP("out of memory for %d bytes",
-		   sizeof(struct ip_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 ip_set *set)
-{
-	struct ip_set_portmap *map = (struct ip_set_portmap *) set->data;
-
-	kfree(map->members);
-	kfree(map);
-
-	set->data = NULL;
-}
-
-static void flush(struct ip_set *set)
-{
-	struct ip_set_portmap *map = (struct ip_set_portmap *) set->data;
-	memset(map->members, 0, bitmap_bytes(map->first_port, map->last_port));
-}
-
-static void list_header(const struct ip_set *set, void *data)
-{
-	struct ip_set_portmap *map = (struct ip_set_portmap *) set->data;
-	struct ip_set_req_portmap_create *header =
-	    (struct ip_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 ip_set *set)
-{
-	struct ip_set_portmap *map = (struct ip_set_portmap *) set->data;
-
-	return bitmap_bytes(map->first_port, map->last_port);
-}
-
-static void list_members(const struct ip_set *set, void *data)
-{
-	struct ip_set_portmap *map = (struct ip_set_portmap *) set->data;
-	int bytes = bitmap_bytes(map->first_port, map->last_port);
-
-	memcpy(data, map->members, bytes);
-}
-
-static struct ip_set_type ip_set_portmap = {
-	.typename		= SETTYPE_NAME,
-	.features		= IPSET_TYPE_PORT | IPSET_DATA_SINGLE,
-	.protocol_version	= IP_SET_PROTOCOL_VERSION,
-	.create			= &create,
-	.destroy		= &destroy,
-	.flush			= &flush,
-	.reqsize		= sizeof(struct ip_set_req_portmap),
-	.addip			= &addport,
-	.addip_kernel		= &addport_kernel,
-	.delip			= &delport,
-	.delip_kernel		= &delport_kernel,
-	.testip			= &testport,
-	.testip_kernel		= &testport_kernel,
-	.header_size		= sizeof(struct ip_set_req_portmap_create),
-	.list_header		= &list_header,
-	.list_members_size	= &list_members_size,
-	.list_members		= &list_members,
-	.me			= THIS_MODULE,
-};
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
-MODULE_DESCRIPTION("portmap type of IP sets");
-
-static int __init init(void)
-{
-	return ip_set_register_set_type(&ip_set_portmap);
-}
-
-static void __exit fini(void)
-{
-	/* FIXME: possible race with ip_set_create() */
-	ip_set_unregister_set_type(&ip_set_portmap);
-}
-
-module_init(init);
-module_exit(fini);
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ipt_SET.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ipt_SET.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ipt_SET.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ipt_SET.c	2006-03-13 13:22:06.000000000 +0100
@@ -10,18 +10,10 @@
 
 /* ipt_SET.c - netfilter target to manipulate IP sets */
 
-#include <linux/types.h>
-#include <linux/ip.h>
-#include <linux/timer.h>
 #include <linux/module.h>
-#include <linux/netfilter.h>
-#include <linux/netdevice.h>
-#include <linux/if.h>
-#include <linux/inetdevice.h>
-#include <net/protocol.h>
-#include <net/checksum.h>
-#include <linux/netfilter_ipv4.h>
-#include <linux/netfilter_ipv4/ip_nat_rule.h>
+#include <linux/skbuff.h>
+
+#include <linux/netfilter_ipv4/ip_tables.h>
 #include <linux/netfilter_ipv4/ipt_set.h>
 
 static unsigned int
@@ -34,12 +26,12 @@
 {
 	const struct ipt_set_info_target *info = targinfo;
 	
-	if (info->add_set.index != IP_SET_INVALID_ID)
-		ip_set_addip_kernel(info->add_set.index,
+	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 != IP_SET_INVALID_ID)
-		ip_set_delip_kernel(info->del_set.index,
+	if (info->del_set.index != NF_SET_INVALID_ID)
+		nf_set_del_kernel(info->del_set.index,
 				    *pskb,
 				    info->del_set.flags);
 
@@ -54,33 +46,35 @@
 {
 	struct ipt_set_info_target *info = 
 		(struct ipt_set_info_target *) targinfo;
-	ip_set_id_t index;
 
 	if (targinfosize != IPT_ALIGN(sizeof(*info))) {
 		DP("bad target info size %u", targinfosize);
 		return 0;
 	}
 
-	if (info->add_set.index != IP_SET_INVALID_ID) {
-		index = ip_set_get_byindex(info->add_set.index);
-		if (index == IP_SET_INVALID_ID) {
-			ip_set_printk("cannot find add_set index %u as target",
-				      info->add_set.index);
+	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.index != IP_SET_INVALID_ID) {
-		index = ip_set_get_byindex(info->del_set.index);
-		if (index == IP_SET_INVALID_ID) {
-			ip_set_printk("cannot find del_set index %u as target",
-				      info->del_set.index);
+	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 */
 		}
-	}
-	if (info->add_set.flags[IP_SET_MAX_BINDINGS] != 0
-	    || info->del_set.flags[IP_SET_MAX_BINDINGS] != 0) {
-		ip_set_printk("That's nasty!");
+	} 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 */
 	}
 
@@ -92,14 +86,14 @@
 	struct ipt_set_info_target *info = targetinfo;
 
 	if (targetsize != IPT_ALIGN(sizeof(struct ipt_set_info_target))) {
-		ip_set_printk("invalid targetsize %d", targetsize);
+		nf_set_printk("invalid targetsize %d", targetsize);
 		return;
 	}
 
-	if (info->add_set.index != IP_SET_INVALID_ID)
-		ip_set_put(info->add_set.index);
-	if (info->del_set.index != IP_SET_INVALID_ID)
-		ip_set_put(info->del_set.index);
+	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 = {
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/ipv4/netfilter/ipt_set.c linux-2.6.15.3-nfset/net/ipv4/netfilter/ipt_set.c
--- linux-2.6.15.3-ipset/net/ipv4/netfilter/ipt_set.c	2006-03-09 13:45:53.000000000 +0100
+++ linux-2.6.15.3-nfset/net/ipv4/netfilter/ipt_set.c	2006-03-13 13:20:50.000000000 +0100
@@ -11,11 +11,9 @@
 /* Kernel module to match an IP set. */
 
 #include <linux/module.h>
-#include <linux/ip.h>
 #include <linux/skbuff.h>
 
 #include <linux/netfilter_ipv4/ip_tables.h>
-#include <linux/netfilter_ipv4/ip_set.h>
 #include <linux/netfilter_ipv4/ipt_set.h>
 
 static inline int
@@ -23,7 +21,7 @@
 	  const struct sk_buff *skb,
 	  int inv)
 {	
-	if (ip_set_testip_kernel(info->index, skb, info->flags))
+	if (nf_set_test_kernel(info->index, skb, info->flags))
 		inv = !inv;
 	return inv;
 }
@@ -40,7 +38,7 @@
 		
 	return match_set(&info->match_set,
 			 skb,
-			 info->match_set.flags[0] & IPSET_MATCH_INV);
+			 info->match_set.flags[0] & NFSET_MATCH_INV);
 }
 
 static int
@@ -52,22 +50,21 @@
 {
 	struct ipt_set_info_match *info = 
 		(struct ipt_set_info_match *) matchinfo;
-	ip_set_id_t index;
 
 	if (matchsize != IPT_ALIGN(sizeof(struct ipt_set_info_match))) {
-		ip_set_printk("invalid matchsize %d", matchsize);
+		nf_set_printk("invalid matchsize %d", matchsize);
 		return 0;
 	}
 
-	index = ip_set_get_byindex(info->match_set.index);
+	info->match_set.index = nf_set_get_byname(info->match_set.name);
 		
-	if (index == IP_SET_INVALID_ID) {
-		ip_set_printk("Cannot find set indentified by id %u to match",
-			      info->match_set.index);
+	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[IP_SET_MAX_BINDINGS] != 0) {
-		ip_set_printk("That's nasty!");
+	if (info->match_set.flags[NF_SET_MAX_STORAGE] != 0) {
+		nf_set_printk("That's nasty!");
 		return 0;	/* error */
 	}
 
@@ -79,11 +76,11 @@
 	struct ipt_set_info_match *info = matchinfo;
 
 	if (matchsize != IPT_ALIGN(sizeof(struct ipt_set_info_match))) {
-		ip_set_printk("invalid matchsize %d", matchsize);
+		nf_set_printk("invalid matchsize %d", matchsize);
 		return;
 	}
 
-	ip_set_put(info->match_set.index);
+	nf_set_put_byindex(info->match_set.index);
 }
 
 static struct ipt_match set_match = {
diff -urN --exclude-from=/usr/src/diff.exclude linux-2.6.15.3-ipset/net/netfilter/Kconfig linux-2.6.15.3-nfset/net/netfilter/Kconfig
--- linux-2.6.15.3-ipset/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-ipset/net/netfilter/Makefile linux-2.6.15.3-nfset/net/netfilter/Makefile
--- linux-2.6.15.3-ipset/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-ipset/net/netfilter/nf_set.c linux-2.6.15.3-nfset/net/netfilter/nf_set.c
--- linux-2.6.15.3-ipset/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-ipset/net/netfilter/nf_set_iphash.c linux-2.6.15.3-nfset/net/netfilter/nf_set_iphash.c
--- linux-2.6.15.3-ipset/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-ipset/net/netfilter/nf_set_ipmap.c linux-2.6.15.3-nfset/net/netfilter/nf_set_ipmap.c
--- linux-2.6.15.3-ipset/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-ipset/net/netfilter/nf_set_ipporthash.c linux-2.6.15.3-nfset/net/netfilter/nf_set_ipporthash.c
--- linux-2.6.15.3-ipset/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-ipset/net/netfilter/nf_set_iptree.c linux-2.6.15.3-nfset/net/netfilter/nf_set_iptree.c
--- linux-2.6.15.3-ipset/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-ipset/net/netfilter/nf_set_macipmap.c linux-2.6.15.3-nfset/net/netfilter/nf_set_macipmap.c
--- linux-2.6.15.3-ipset/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-ipset/net/netfilter/nf_set_nethash.c linux-2.6.15.3-nfset/net/netfilter/nf_set_nethash.c
--- linux-2.6.15.3-ipset/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-ipset/net/netfilter/nf_set_portmap.c linux-2.6.15.3-nfset/net/netfilter/nf_set_portmap.c
--- linux-2.6.15.3-ipset/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);
