X-Git-Url: http://git.archive.openwrt.org/?p=project%2Ffirewall3.git;a=blobdiff_plain;f=iptables.c;h=10bfea5e084333cf7b2db28ebda23acaa1c0dc2e;hp=4956ef70211ac9267ab6f7cf8e4098e3c7a18ba3;hb=6039c7f4b0052c4da21520cdd604f04a5a67f50d;hpb=3833ad4b0a46778d718d5146ca567d23d0b23291

diff --git a/iptables.c b/iptables.c
index 4956ef7..10bfea5 100644
--- a/iptables.c
+++ b/iptables.c
@@ -1,7 +1,7 @@
 /*
  * firewall3 - 3rd OpenWrt UCI firewall implementation
  *
- *   Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
+ *   Copyright (C) 2013 Jo-Philipp Wich <jo@mein.io>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -16,13 +16,65 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
+#define _GNU_SOURCE /* RTLD_NEXT */
+
+/* include userspace headers */
+#include <dlfcn.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <sys/utsname.h>
+#include <sys/socket.h>
+
+/* prevent indirect inclusion of kernel headers */
+#define _LINUX_IF_H
+#define _LINUX_IN_H
+#define _LINUX_IN6_H
+
+/* prevent libiptc from including kernel headers */
+#define _FWCHAINS_KERNEL_HEADERS_H
+
+/* finally include libiptc and xtables */
+#include <libiptc/libiptc.h>
+#include <libiptc/libip6tc.h>
+#include <xtables.h>
+
+#include "options.h"
+
+/* xtables interface */
+#if (XTABLES_VERSION_CODE >= 10)
+# include "xtables-10.h"
+#elif (XTABLES_VERSION_CODE == 5)
+# include "xtables-5.h"
+#else
+# error "Unsupported xtables version"
+#endif
+
 #include "iptables.h"
 
 
+struct fw3_ipt_rule {
+	struct fw3_ipt_handle *h;
+
+	union {
+		struct ipt_entry e;
+		struct ip6t_entry e6;
+	};
+
+	struct xtables_rule_match *matches;
+	struct xtables_target *target;
+
+	int argc;
+	char **argv;
+
+	uint32_t protocol;
+	bool protocol_loaded;
+};
+
 static struct option base_opts[] = {
 	{ .name = "match",  .has_arg = 1, .val = 'm' },
 	{ .name = "jump",   .has_arg = 1, .val = 'j' },
-	{ .name = "append", .has_arg = 1, .val = 'A' },
 	{ NULL }
 };
 
@@ -30,16 +82,32 @@ static struct xtables_globals xtg = {
 	.option_offset = 0,
 	.program_version = "4",
 	.orig_opts = base_opts,
+#if XTABLES_VERSION_CODE > 10
+	.compat_rev = xtables_compatible_revision,
+#endif
 };
 
 static struct xtables_globals xtg6 = {
 	.option_offset = 0,
 	.program_version = "6",
 	.orig_opts = base_opts,
+#if XTABLES_VERSION_CODE > 10
+	.compat_rev = xtables_compatible_revision,
+#endif
 };
 
+static struct {
+	bool retain;
+	int mcount, tcount;
+	struct xtables_match **matches;
+	struct xtables_target **targets;
+	void (*register_match)(struct xtables_match *);
+	void (*register_target)(struct xtables_target *);
+} xext;
+
+
 /* Required by certain extensions like SNAT and DNAT */
-int kernel_version;
+int kernel_version = 0;
 
 void
 get_kernel_version(void)
@@ -51,12 +119,23 @@ get_kernel_version(void)
 		sprintf(uts.release, "3.0.0");
 
 	sscanf(uts.release, "%d.%d.%d", &x, &y, &z);
-	kernel_version = LINUX_VERSION(x, y, z);
+	kernel_version = 0x10000 * x + 0x100 * y + z;
+}
+
+static void fw3_init_extensions(void)
+{
+	init_extensions();
+	init_extensions4();
+
+#ifndef DISABLE_IPV6
+	init_extensions6();
+#endif
 }
 
 struct fw3_ipt_handle *
 fw3_ipt_open(enum fw3_family family, enum fw3_table table)
 {
+	int i;
 	struct fw3_ipt_handle *h;
 
 	h = fw3_alloc(sizeof(*h));
@@ -65,12 +144,14 @@ fw3_ipt_open(enum fw3_family family, enum fw3_table table)
 
 	if (family == FW3_FAMILY_V6)
 	{
+#ifndef DISABLE_IPV6
 		h->family = FW3_FAMILY_V6;
 		h->table  = table;
 		h->handle = ip6tc_init(fw3_flag_names[table]);
 
 		xtables_set_params(&xtg6);
 		xtables_set_nfproto(NFPROTO_IPV6);
+#endif
 	}
 	else
 	{
@@ -88,15 +169,16 @@ fw3_ipt_open(enum fw3_family family, enum fw3_table table)
 		return NULL;
 	}
 
-	xtables_pending_matches = NULL;
-	xtables_pending_targets = NULL;
+	fw3_xt_reset();
+	fw3_init_extensions();
 
-	xtables_matches = NULL;
-	xtables_targets = NULL;
+	if (xext.register_match)
+		for (i = 0; i < xext.mcount; i++)
+			xext.register_match(xext.matches[i]);
 
-	init_extensions();
-	init_extensions4();
-	init_extensions6();
+	if (xext.register_target)
+		for (i = 0; i < xext.tcount; i++)
+			xext.register_target(xext.targets[i]);
 
 	return h;
 }
@@ -121,43 +203,38 @@ fw3_ipt_set_policy(struct fw3_ipt_handle *h, const char *chain,
 	if (fw3_pr_debug)
 		debug(h, "-P %s %s\n", chain, fw3_flag_names[policy]);
 
+#ifndef DISABLE_IPV6
 	if (h->family == FW3_FAMILY_V6)
 		ip6tc_set_policy(chain, fw3_flag_names[policy], NULL, h->handle);
 	else
+#endif
 		iptc_set_policy(chain, fw3_flag_names[policy], NULL, h->handle);
 }
 
 void
-fw3_ipt_delete_chain(struct fw3_ipt_handle *h, const char *chain)
+fw3_ipt_flush_chain(struct fw3_ipt_handle *h, const char *chain)
 {
 	if (fw3_pr_debug)
-	{
 		debug(h, "-F %s\n", chain);
-		debug(h, "-X %s\n", chain);
-	}
 
+#ifndef DISABLE_IPV6
 	if (h->family == FW3_FAMILY_V6)
-	{
-		if (ip6tc_flush_entries(chain, h->handle))
-			ip6tc_delete_chain(chain, h->handle);
-	}
+		ip6tc_flush_entries(chain, h->handle);
 	else
-	{
-		if (iptc_flush_entries(chain, h->handle))
-			iptc_delete_chain(chain, h->handle);
-	}
+#endif
+		iptc_flush_entries(chain, h->handle);
 }
 
-void
-fw3_ipt_delete_rules(struct fw3_ipt_handle *h, const char *target)
+static void
+delete_rules(struct fw3_ipt_handle *h, const char *target)
 {
 	unsigned int num;
 	const struct ipt_entry *e;
-	const struct ip6t_entry *e6;
 	const char *chain;
 	const char *t;
 	bool found;
 
+#ifndef DISABLE_IPV6
 	if (h->family == FW3_FAMILY_V6)
 	{
 		for (chain = ip6tc_first_chain(h->handle);
@@ -167,6 +244,7 @@ fw3_ipt_delete_rules(struct fw3_ipt_handle *h, const char *target)
 			do {
 				found = false;
 
+				const struct ip6t_entry *e6;
 				for (num = 0, e6 = ip6tc_first_rule(chain, h->handle);
 					 e6 != NULL;
 					 num++, e6 = ip6tc_next_rule(e6, h->handle))
@@ -187,6 +265,7 @@ fw3_ipt_delete_rules(struct fw3_ipt_handle *h, const char *target)
 		}
 	}
 	else
+#endif
 	{
 		for (chain = iptc_first_chain(h->handle);
 		     chain != NULL;
@@ -217,6 +296,102 @@ fw3_ipt_delete_rules(struct fw3_ipt_handle *h, const char *target)
 }
 
 void
+fw3_ipt_delete_chain(struct fw3_ipt_handle *h, const char *chain)
+{
+	delete_rules(h, chain);
+
+	if (fw3_pr_debug)
+		debug(h, "-X %s\n", chain);
+
+#ifndef DISABLE_IPV6
+	if (h->family == FW3_FAMILY_V6)
+		ip6tc_delete_chain(chain, h->handle);
+	else
+#endif
+		iptc_delete_chain(chain, h->handle);
+}
+
+static bool
+has_rule_tag(const void *base, unsigned int start, unsigned int end)
+{
+	unsigned int i;
+	const struct xt_entry_match *em;
+
+	for (i = start; i < end; i += em->u.match_size)
+	{
+		em = base + i;
+
+		if (strcmp(em->u.user.name, "comment"))
+			continue;
+
+		if (!memcmp(em->data, "!fw3", 4))
+			return true;
+	}
+
+	return false;
+}
+
+void
+fw3_ipt_delete_id_rules(struct fw3_ipt_handle *h, const char *chain)
+{
+	unsigned int num;
+	const struct ipt_entry *e;
+	bool found;
+
+#ifndef DISABLE_IPV6
+	if (h->family == FW3_FAMILY_V6)
+	{
+		if (!ip6tc_is_chain(chain, h->handle))
+			return;
+
+		do {
+			found = false;
+
+			const struct ip6t_entry *e6;
+			for (num = 0, e6 = ip6tc_first_rule(chain, h->handle);
+				 e6 != NULL;
+				 num++, e6 = ip6tc_next_rule(e6, h->handle))
+			{
+				if (has_rule_tag(e6, sizeof(*e6), e6->target_offset))
+				{
+					if (fw3_pr_debug)
+						debug(h, "-D %s %u\n", chain, num + 1);
+
+					ip6tc_delete_num_entry(chain, num, h->handle);
+					found = true;
+					break;
+				}
+			}
+		} while (found);
+	}
+	else
+#endif
+	{
+		if (!iptc_is_chain(chain, h->handle))
+			return;
+
+		do {
+			found = false;
+
+			for (num = 0, e = iptc_first_rule(chain, h->handle);
+				 e != NULL;
+				 num++, e = iptc_next_rule(e, h->handle))
+			{
+				if (has_rule_tag(e, sizeof(*e), e->target_offset))
+				{
+					if (fw3_pr_debug)
+						debug(h, "-D %s %u\n", chain, num + 1);
+
+					iptc_delete_num_entry(chain, num, h->handle);
+					found = true;
+					break;
+				}
+			}
+		} while (found);
+	}
+}
+
+void
 fw3_ipt_create_chain(struct fw3_ipt_handle *h, const char *fmt, ...)
 {
 	char buf[32];
@@ -237,6 +412,7 @@ fw3_ipt_flush(struct fw3_ipt_handle *h)
 {
 	const char *chain;
 
+#ifndef DISABLE_IPV6
 	if (h->family == FW3_FAMILY_V6)
 	{
 		for (chain = ip6tc_first_chain(h->handle);
@@ -254,6 +430,7 @@ fw3_ipt_flush(struct fw3_ipt_handle *h)
 		}
 	}
 	else
+#endif
 	{
 		for (chain = iptc_first_chain(h->handle);
 		     chain != NULL;
@@ -271,24 +448,93 @@ fw3_ipt_flush(struct fw3_ipt_handle *h)
 	}
 }
 
+static bool
+chain_is_empty(struct fw3_ipt_handle *h, const char *chain)
+{
+#ifndef DISABLE_IPV6
+	if (h->family == FW3_FAMILY_V6)
+		return (!ip6tc_builtin(chain, h->handle) &&
+		        !ip6tc_first_rule(chain, h->handle));
+#endif
+
+	return (!iptc_builtin(chain, h->handle) &&
+	        !iptc_first_rule(chain, h->handle));
+}
+
+void
+fw3_ipt_gc(struct fw3_ipt_handle *h)
+{
+	const char *chain;
+	bool found;
+
+#ifndef DISABLE_IPV6
+	if (h->family == FW3_FAMILY_V6)
+	{
+		do {
+			found = false;
+
+			for (chain = ip6tc_first_chain(h->handle);
+				 chain != NULL;
+				 chain = ip6tc_next_chain(h->handle))
+			{
+				if (!chain_is_empty(h, chain))
+					continue;
+
+				fw3_ipt_delete_chain(h, chain);
+				found = true;
+				break;
+			}
+		} while(found);
+	}
+	else
+#endif
+	{
+		do {
+			found = false;
+
+			for (chain = iptc_first_chain(h->handle);
+				 chain != NULL;
+				 chain = iptc_next_chain(h->handle))
+			{
+				warn("C=%s\n", chain);
+
+				if (!chain_is_empty(h, chain))
+					continue;
+
+				warn("D=%s\n", chain);
+
+				fw3_ipt_delete_chain(h, chain);
+				found = true;
+				break;
+			}
+		} while (found);
+	}
+}
+
 void
 fw3_ipt_commit(struct fw3_ipt_handle *h)
 {
 	int rv;
 
+#ifndef DISABLE_IPV6
 	if (h->family == FW3_FAMILY_V6)
 	{
 		rv = ip6tc_commit(h->handle);
 		if (!rv)
-			fprintf(stderr, "ip6tc_commit(): %s\n", ip6tc_strerror(errno));
+			warn("ip6tc_commit(): %s", ip6tc_strerror(errno));
 	}
 	else
+#endif
 	{
 		rv = iptc_commit(h->handle);
 		if (!rv)
-			fprintf(stderr, "iptc_commit(): %s\n", iptc_strerror(errno));
+			warn("iptc_commit(): %s", iptc_strerror(errno));
 	}
+}
 
+void
+fw3_ipt_close(struct fw3_ipt_handle *h)
+{
 	free(h);
 }
 
@@ -310,9 +556,11 @@ fw3_ipt_rule_new(struct fw3_ipt_handle *h)
 static bool
 is_chain(struct fw3_ipt_handle *h, const char *name)
 {
+#ifndef DISABLE_IPV6
 	if (h->family == FW3_FAMILY_V6)
 		return ip6tc_is_chain(name, h->handle);
 	else
+#endif
 		return iptc_is_chain(name, h->handle);
 }
 
@@ -332,7 +580,13 @@ get_protoname(struct fw3_ipt_rule *r)
 static struct xtables_match *
 find_match(struct fw3_ipt_rule *r, const char *name)
 {
-	return xtables_find_match(name, XTF_TRY_LOAD, &r->matches);
+	struct xtables_match *m;
+
+	xext.retain = true;
+	m = xtables_find_match(name, XTF_TRY_LOAD, &r->matches);
+	xext.retain = false;
+
+	return m;
 }
 
 static void
@@ -347,16 +601,14 @@ init_match(struct fw3_ipt_rule *r, struct xtables_match *m, bool no_clone)
 	s = XT_ALIGN(sizeof(struct xt_entry_match)) + m->size;
 
 	m->m = fw3_alloc(s);
-	strcpy(m->m->u.user.name, m->real_name ? m->real_name : m->name);
+
+	fw3_xt_set_match_name(m);
+
 	m->m->u.user.revision = m->revision;
 	m->m->u.match_size = s;
 
 	/* free previous userspace data */
-	if (m->udata_size)
-	{
-		free(m->udata);
-		m->udata = fw3_alloc(m->udata_size);
-	}
+	fw3_xt_free_match_udata(m);
 
 	if (m->init)
 		m->init(m->m);
@@ -367,14 +619,7 @@ init_match(struct fw3_ipt_rule *r, struct xtables_match *m, bool no_clone)
 
 	/* merge option table */
 	g = (r->h->family == FW3_FAMILY_V6) ? &xtg6 : &xtg;
-
-	if (m->x6_options)
-		g->opts = xtables_options_xfrm(g->orig_opts, g->opts,
-									   m->x6_options, &m->option_offset);
-
-	if (m->extra_opts)
-		g->opts = xtables_merge_options(g->orig_opts, g->opts,
-										m->extra_opts, &m->option_offset);
+	fw3_xt_merge_match_options(g, m);
 }
 
 static bool
@@ -401,51 +646,51 @@ load_protomatch(struct fw3_ipt_rule *r)
 }
 
 static struct xtables_target *
-get_target(struct fw3_ipt_rule *r, const char *name)
+find_target(struct fw3_ipt_rule *r, const char *name)
 {
-	size_t s;
 	struct xtables_target *t;
-	struct xtables_globals *g;
 
-	bool chain = is_chain(r->h, name);
+	xext.retain = true;
 
-	if (chain)
-		t = xtables_find_target(XT_STANDARD_TARGET, XTF_LOAD_MUST_SUCCEED);
+	if (is_chain(r->h, name))
+		t = xtables_find_target(XT_STANDARD_TARGET, XTF_TRY_LOAD);
 	else
 		t = xtables_find_target(name, XTF_TRY_LOAD);
 
+	xext.retain = false;
+
+	return t;
+}
+
+static struct xtables_target *
+get_target(struct fw3_ipt_rule *r, const char *name)
+{
+	size_t s;
+	struct xtables_target *t;
+	struct xtables_globals *g;
+
+	t = find_target(r, name);
+
 	if (!t)
 		return NULL;
 
 	s = XT_ALIGN(sizeof(struct xt_entry_target)) + t->size;
 	t->t = fw3_alloc(s);
 
-	if (!t->real_name)
-		strcpy(t->t->u.user.name, name);
-	else
-		strcpy(t->t->u.user.name, t->real_name);
+	fw3_xt_set_target_name(t, name);
 
 	t->t->u.user.revision = t->revision;
 	t->t->u.target_size = s;
 
-	if (t->udata_size)
-	{
-		free(t->udata);
-		t->udata = fw3_alloc(t->udata_size);
-	}
+	/* free previous userspace data */
+	fw3_xt_free_target_udata(t);
 
 	if (t->init)
 		t->init(t->t);
 
 	/* merge option table */
 	g = (r->h->family == FW3_FAMILY_V6) ? &xtg6 : &xtg;
-
-	if (t->x6_options)
-		g->opts = xtables_options_xfrm(g->orig_opts, g->opts,
-		                               t->x6_options, &t->option_offset);
-	else
-		g->opts = xtables_merge_options(g->orig_opts, g->opts,
-		                                t->extra_opts, &t->option_offset);
+	fw3_xt_merge_target_options(g, t);
 
 	r->target = t;
 
@@ -462,6 +707,7 @@ fw3_ipt_rule_proto(struct fw3_ipt_rule *r, struct fw3_protocol *proto)
 
 	pr = proto->protocol;
 
+#ifndef DISABLE_IPV6
 	if (r->h->family == FW3_FAMILY_V6)
 	{
 		if (pr == 1)
@@ -474,6 +720,7 @@ fw3_ipt_rule_proto(struct fw3_ipt_rule *r, struct fw3_protocol *proto)
 			r->e6.ipv6.invflags |= XT_INV_PROTO;
 	}
 	else
+#endif
 	{
 		r->e.ip.proto = pr;
 
@@ -488,6 +735,7 @@ void
 fw3_ipt_rule_in_out(struct fw3_ipt_rule *r,
                     struct fw3_device *in, struct fw3_device *out)
 {
+#ifndef DISABLE_IPV6
 	if (r->h->family == FW3_FAMILY_V6)
 	{
 		if (in && !in->any)
@@ -509,6 +757,7 @@ fw3_ipt_rule_in_out(struct fw3_ipt_rule *r,
 		}
 	}
 	else
+#endif
 	{
 		if (in && !in->any)
 		{
@@ -531,35 +780,10 @@ fw3_ipt_rule_in_out(struct fw3_ipt_rule *r,
 }
 
 
-static void
-ip4prefix2mask(int prefix, struct in_addr *mask)
-{
-	mask->s_addr = htonl(~((1 << (32 - prefix)) - 1));
-}
-
-static void
-ip6prefix2mask(int prefix, struct in6_addr *mask)
-{
-	char *p = (char *)mask;
-
-	if (prefix > 0)
-	{
-		memset(p, 0xff, prefix / 8);
-		memset(p + (prefix / 8) + 1, 0, (128 - prefix) / 8);
-		p[prefix / 8] = 0xff << (8 - (prefix & 7));
-	}
-	else
-	{
-		memset(mask, 0, sizeof(*mask));
-	}
-}
-
 void
 fw3_ipt_rule_src_dest(struct fw3_ipt_rule *r,
                       struct fw3_address *src, struct fw3_address *dest)
 {
-	int i;
-
 	if ((src && src->range) || (dest && dest->range))
 	{
 		fw3_ipt_rule_addarg(r, false, "-m", "iprange");
@@ -570,23 +794,26 @@ fw3_ipt_rule_src_dest(struct fw3_ipt_rule *r,
 		if (src->range)
 		{
 			fw3_ipt_rule_addarg(r, src->invert, "--src-range",
-			                    fw3_address_to_string(src, false));
+			                    fw3_address_to_string(src, false, false));
 		}
+#ifndef DISABLE_IPV6
 		else if (r->h->family == FW3_FAMILY_V6)
 		{
 			r->e6.ipv6.src = src->address.v6;
-			ip6prefix2mask(src->mask, &r->e6.ipv6.smsk);
+			r->e6.ipv6.smsk = src->mask.v6;
 
+			int i;
 			for (i = 0; i < 4; i++)
 				r->e6.ipv6.src.s6_addr32[i] &= r->e6.ipv6.smsk.s6_addr32[i];
 
 			if (src->invert)
 				r->e6.ipv6.invflags |= IP6T_INV_SRCIP;
 		}
+#endif
 		else
 		{
 			r->e.ip.src = src->address.v4;
-			ip4prefix2mask(src->mask, &r->e.ip.smsk);
+			r->e.ip.smsk = src->mask.v4;
 
 			r->e.ip.src.s_addr &= r->e.ip.smsk.s_addr;
 
@@ -600,23 +827,26 @@ fw3_ipt_rule_src_dest(struct fw3_ipt_rule *r,
 		if (dest->range)
 		{
 			fw3_ipt_rule_addarg(r, dest->invert, "--dst-range",
-			                    fw3_address_to_string(dest, false));
+			                    fw3_address_to_string(dest, false, false));
 		}
+#ifndef DISABLE_IPV6
 		else if (r->h->family == FW3_FAMILY_V6)
 		{
 			r->e6.ipv6.dst = dest->address.v6;
-			ip6prefix2mask(dest->mask, &r->e6.ipv6.dmsk);
+			r->e6.ipv6.dmsk = dest->mask.v6;
 
+			int i;
 			for (i = 0; i < 4; i++)
 				r->e6.ipv6.dst.s6_addr32[i] &= r->e6.ipv6.dmsk.s6_addr32[i];
 
 			if (dest->invert)
 				r->e6.ipv6.invflags |= IP6T_INV_DSTIP;
 		}
+#endif
 		else
 		{
 			r->e.ip.dst = dest->address.v4;
-			ip4prefix2mask(dest->mask, &r->e.ip.dmsk);
+			r->e.ip.dmsk = dest->mask.v4;
 
 			r->e.ip.dst.s_addr &= r->e.ip.dmsk.s_addr;
 
@@ -660,13 +890,29 @@ fw3_ipt_rule_sport_dport(struct fw3_ipt_rule *r,
 }
 
 void
+fw3_ipt_rule_device(struct fw3_ipt_rule *r, const char *device, bool out)
+{
+	if (device) {
+		struct fw3_device dev = { .any = false };
+		strncpy(dev.name, device, sizeof(dev.name) - 1);
+		fw3_ipt_rule_in_out(r, (out) ? NULL : &dev, (out) ? &dev : NULL);
+	}
+}
+
+void
 fw3_ipt_rule_mac(struct fw3_ipt_rule *r, struct fw3_mac *mac)
 {
+	char buf[sizeof("ff:ff:ff:ff:ff:ff\0")];
+	uint8_t *addr = mac->mac.ether_addr_octet;
+
 	if (!mac)
 		return;
 
+	sprintf(buf, "%02x:%02x:%02x:%02x:%02x:%02x",
+	        addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
+
 	fw3_ipt_rule_addarg(r, false, "-m", "mac");
-	fw3_ipt_rule_addarg(r, mac->invert, "--mac-source", ether_ntoa(&mac->mac));
+	fw3_ipt_rule_addarg(r, mac->invert, "--mac-source", buf);
 }
 
 void
@@ -677,6 +923,7 @@ fw3_ipt_rule_icmptype(struct fw3_ipt_rule *r, struct fw3_icmptype *icmp)
 	if (!icmp)
 		return;
 
+#ifndef DISABLE_IPV6
 	if (r->h->family == FW3_FAMILY_V6)
 	{
 		if (icmp->code6_min == 0 && icmp->code6_max == 0xFF)
@@ -687,6 +934,7 @@ fw3_ipt_rule_icmptype(struct fw3_ipt_rule *r, struct fw3_icmptype *icmp)
 		fw3_ipt_rule_addarg(r, icmp->invert, "--icmpv6-type", buf);
 	}
 	else
+#endif
 	{
 		if (icmp->code_min == 0 && icmp->code_max == 0xFF)
 			sprintf(buf, "%u", icmp->type);
@@ -718,29 +966,35 @@ fw3_ipt_rule_limit(struct fw3_ipt_rule *r, struct fw3_limit *limit)
 }
 
 void
-fw3_ipt_rule_ipset(struct fw3_ipt_rule *r, struct fw3_ipset *ipset,
-                   bool invert)
+fw3_ipt_rule_ipset(struct fw3_ipt_rule *r, struct fw3_setmatch *match)
 {
 	char buf[sizeof("dst,dst,dst\0")];
 	char *p = buf;
+	int i = 0;
 
+	struct fw3_ipset *set;
 	struct fw3_ipset_datatype *type;
 
-	if (!ipset)
+	if (!match || !match->set || !match->ptr)
 		return;
 
-	list_for_each_entry(type, &ipset->datatypes, list)
+	set = match->ptr;
+	list_for_each_entry(type, &set->datatypes, list)
 	{
+		if (i >= 3)
+			break;
+
 		if (p > buf)
 			*p++ = ',';
 
-		p += sprintf(p, "%s", type->dest ? "dst" : "src");
+		p += sprintf(p, "%s", match->dir[i] ? match->dir[i] : type->dir);
+		i++;
 	}
 
 	fw3_ipt_rule_addarg(r, false, "-m", "set");
 
-	fw3_ipt_rule_addarg(r, invert, "--match-set",
-	                    ipset->external ? ipset->external : ipset->name);
+	fw3_ipt_rule_addarg(r, match->invert, "--match-set",
+	                    set->external ? set->external : set->name);
 
 	fw3_ipt_rule_addarg(r, false, buf, NULL);
 }
@@ -765,8 +1019,8 @@ fw3_ipt_rule_time(struct fw3_ipt_rule *r, struct fw3_time *time)
 
 	fw3_ipt_rule_addarg(r, false, "-m", "time");
 
-	if (time->utc)
-		fw3_ipt_rule_addarg(r, false, "--utc", NULL);
+	if (!time->utc)
+		fw3_ipt_rule_addarg(r, false, "--kerneltz", NULL);
 
 	if (d1)
 	{
@@ -804,7 +1058,7 @@ fw3_ipt_rule_time(struct fw3_ipt_rule *r, struct fw3_time *time)
 	{
 		for (i = 1, p = buf; i < 32; i++)
 		{
-			if (hasbit(time->monthdays, i))
+			if (fw3_hasbit(time->monthdays, i))
 			{
 				if (p > buf)
 					*p++ = ',';
@@ -813,14 +1067,14 @@ fw3_ipt_rule_time(struct fw3_ipt_rule *r, struct fw3_time *time)
 			}
 		}
 
-		fw3_ipt_rule_addarg(r, hasbit(time->monthdays, 0), "--monthdays", buf);
+		fw3_ipt_rule_addarg(r, fw3_hasbit(time->monthdays, 0), "--monthdays", buf);
 	}
 
 	if (time->weekdays & 0xFE)
 	{
 		for (i = 1, p = buf; i < 8; i++)
 		{
-			if (hasbit(time->weekdays, i))
+			if (fw3_hasbit(time->weekdays, i))
 			{
 				if (p > buf)
 					*p++ = ',';
@@ -829,7 +1083,7 @@ fw3_ipt_rule_time(struct fw3_ipt_rule *r, struct fw3_time *time)
 			}
 		}
 
-		fw3_ipt_rule_addarg(r, hasbit(time->weekdays, 0), "--weekdays", buf);
+		fw3_ipt_rule_addarg(r, fw3_hasbit(time->weekdays, 0), "--weekdays", buf);
 	}
 }
 
@@ -891,15 +1145,16 @@ fw3_ipt_rule_extra(struct fw3_ipt_rule *r, const char *extra)
 	free(s);
 }
 
+#ifndef DISABLE_IPV6
 static void
 rule_print6(struct ip6t_entry *e)
 {
-	char buf[INET6_ADDRSTRLEN];
+	char buf1[INET6_ADDRSTRLEN], buf2[INET6_ADDRSTRLEN];
 	char *pname;
 
 	if (e->ipv6.flags & IP6T_F_PROTO)
 	{
-		if (e->ipv6.flags & XT_INV_PROTO)
+		if (e->ipv6.invflags & XT_INV_PROTO)
 			printf(" !");
 
 		pname = get_protoname(container_of(e, struct fw3_ipt_rule, e6));
@@ -912,7 +1167,7 @@ rule_print6(struct ip6t_entry *e)
 
 	if (e->ipv6.iniface[0])
 	{
-		if (e->ipv6.flags & IP6T_INV_VIA_IN)
+		if (e->ipv6.invflags & IP6T_INV_VIA_IN)
 			printf(" !");
 
 		printf(" -i %s", e->ipv6.iniface);
@@ -920,7 +1175,7 @@ rule_print6(struct ip6t_entry *e)
 
 	if (e->ipv6.outiface[0])
 	{
-		if (e->ipv6.flags & IP6T_INV_VIA_OUT)
+		if (e->ipv6.invflags & IP6T_INV_VIA_OUT)
 			printf(" !");
 
 		printf(" -o %s", e->ipv6.outiface);
@@ -928,33 +1183,36 @@ rule_print6(struct ip6t_entry *e)
 
 	if (memcmp(&e->ipv6.src, &in6addr_any, sizeof(struct in6_addr)))
 	{
-		if (e->ipv6.flags & IP6T_INV_SRCIP)
+		if (e->ipv6.invflags & IP6T_INV_SRCIP)
 			printf(" !");
 
-		printf(" -s %s/%u", inet_ntop(AF_INET6, &e->ipv6.src, buf, sizeof(buf)),
-		                    xtables_ip6mask_to_cidr(&e->ipv6.smsk));
+		printf(" -s %s/%s",
+		       inet_ntop(AF_INET6, &e->ipv6.src, buf1, sizeof(buf1)),
+		       inet_ntop(AF_INET6, &e->ipv6.smsk, buf2, sizeof(buf2)));
 	}
 
 	if (memcmp(&e->ipv6.dst, &in6addr_any, sizeof(struct in6_addr)))
 	{
-		if (e->ipv6.flags & IP6T_INV_DSTIP)
+		if (e->ipv6.invflags & IP6T_INV_DSTIP)
 			printf(" !");
 
-		printf(" -d %s/%u", inet_ntop(AF_INET6, &e->ipv6.dst, buf, sizeof(buf)),
-		                    xtables_ip6mask_to_cidr(&e->ipv6.dmsk));
+		printf(" -d %s/%s",
+		       inet_ntop(AF_INET6, &e->ipv6.dst, buf1, sizeof(buf1)),
+		       inet_ntop(AF_INET6, &e->ipv6.dmsk, buf2, sizeof(buf2)));
 	}
 }
+#endif
 
 static void
 rule_print4(struct ipt_entry *e)
 {
 	struct in_addr in_zero = { 0 };
-	char buf[sizeof("255.255.255.255\0")];
+	char buf1[sizeof("255.255.255.255\0")], buf2[sizeof("255.255.255.255\0")];
 	char *pname;
 
 	if (e->ip.proto)
 	{
-		if (e->ip.flags & XT_INV_PROTO)
+		if (e->ip.invflags & XT_INV_PROTO)
 			printf(" !");
 
 		pname = get_protoname(container_of(e, struct fw3_ipt_rule, e));
@@ -967,7 +1225,7 @@ rule_print4(struct ipt_entry *e)
 
 	if (e->ip.iniface[0])
 	{
-		if (e->ip.flags & IPT_INV_VIA_IN)
+		if (e->ip.invflags & IPT_INV_VIA_IN)
 			printf(" !");
 
 		printf(" -i %s", e->ip.iniface);
@@ -975,7 +1233,7 @@ rule_print4(struct ipt_entry *e)
 
 	if (e->ip.outiface[0])
 	{
-		if (e->ip.flags & IPT_INV_VIA_OUT)
+		if (e->ip.invflags & IPT_INV_VIA_OUT)
 			printf(" !");
 
 		printf(" -o %s", e->ip.outiface);
@@ -983,54 +1241,39 @@ rule_print4(struct ipt_entry *e)
 
 	if (memcmp(&e->ip.src, &in_zero, sizeof(struct in_addr)))
 	{
-		if (e->ip.flags & IPT_INV_SRCIP)
+		if (e->ip.invflags & IPT_INV_SRCIP)
 			printf(" !");
 
-		printf(" -s %s/%u", inet_ntop(AF_INET, &e->ip.src, buf, sizeof(buf)),
-		                    xtables_ipmask_to_cidr(&e->ip.smsk));
+		printf(" -s %s/%s",
+		       inet_ntop(AF_INET, &e->ip.src, buf1, sizeof(buf1)),
+		       inet_ntop(AF_INET, &e->ip.smsk, buf2, sizeof(buf2)));
 	}
 
 	if (memcmp(&e->ip.dst, &in_zero, sizeof(struct in_addr)))
 	{
-		if (e->ip.flags & IPT_INV_DSTIP)
+		if (e->ip.invflags & IPT_INV_DSTIP)
 			printf(" !");
 
-		printf(" -d %s/%u", inet_ntop(AF_INET, &e->ip.dst, buf, sizeof(buf)),
-		                    xtables_ipmask_to_cidr(&e->ip.dmsk));
+		printf(" -d %s/%s",
+		       inet_ntop(AF_INET, &e->ip.dst, buf1, sizeof(buf1)),
+		       inet_ntop(AF_INET, &e->ip.dmsk, buf2, sizeof(buf2)));
 	}
 }
 
 static void
-rule_print(struct fw3_ipt_rule *r, const char *chain)
+rule_print(struct fw3_ipt_rule *r, const char *prefix, const char *chain)
 {
-	struct xtables_rule_match *rm;
-	struct xtables_match *m;
-	struct xtables_target *t;
-
-	debug(r->h, "-A %s", chain);
+	debug(r->h, "%s %s", prefix, chain);
 
+#ifndef DISABLE_IPV6
 	if (r->h->family == FW3_FAMILY_V6)
 		rule_print6(&r->e6);
 	else
+#endif
 		rule_print4(&r->e);
 
-	for (rm = r->matches; rm; rm = rm->next)
-	{
-		m = rm->match;
-		printf(" -m %s", m->alias ? m->alias(m->m) : m->m->u.user.name);
-
-		if (m->save)
-			m->save(&r->e.ip, m->m);
-	}
-
-	if (r->target)
-	{
-		t = r->target;
-		printf(" -j %s", t->alias ? t->alias(t->t) : t->t->u.user.name);
-
-		if (t->save)
-			t->save(&r->e.ip, t->t);
-	}
+	fw3_xt_print_matches(&r->e.ip, r->matches);
+	fw3_xt_print_target(&r->e.ip, r->target);
 
 	printf("\n");
 }
@@ -1042,7 +1285,7 @@ parse_option(struct fw3_ipt_rule *r, int optc, bool inv)
 	struct xtables_match *em;
 
 	/* is a target option */
-	if (r->target && (r->target->parse || r->target->x6_parse) &&
+	if (r->target && fw3_xt_has_target_parse(r->target) &&
 		optc >= r->target->option_offset &&
 		optc < (r->target->option_offset + 256))
 	{
@@ -1055,7 +1298,7 @@ parse_option(struct fw3_ipt_rule *r, int optc, bool inv)
 	{
 		em = m->match;
 
-		if (m->completed || (!em->parse && !em->x6_parse))
+		if (m->completed || !fw3_xt_has_match_parse(em))
 			continue;
 
 		if (optc < em->option_offset ||
@@ -1078,12 +1321,10 @@ parse_option(struct fw3_ipt_rule *r, int optc, bool inv)
 	}
 
 	if (optc == ':')
-		fprintf(stderr, "parse_option(): option '%s' needs argument\n",
-		        r->argv[optind-1]);
+		warn("parse_option(): option '%s' needs argument", r->argv[optind-1]);
 
 	if (optc == '?')
-		fprintf(stderr, "parse_option(): unknown option '%s'\n",
-		        r->argv[optind-1]);
+		warn("parse_option(): unknown option '%s'", r->argv[optind-1]);
 
 	return false;
 }
@@ -1115,16 +1356,173 @@ fw3_ipt_rule_addarg(struct fw3_ipt_rule *r, bool inv,
 		r->argv[r->argc++] = fw3_strdup(v);
 }
 
-void
-fw3_ipt_rule_append(struct fw3_ipt_rule *r, const char *fmt, ...)
+static unsigned char *
+rule_mask(struct fw3_ipt_rule *r)
 {
 	size_t s;
+	unsigned char *p, *mask = NULL;
+	struct xtables_rule_match *m;
+
+#define SZ(x) XT_ALIGN(sizeof(struct x))
+
+#ifndef DISABLE_IPV6
+	if (r->h->family == FW3_FAMILY_V6)
+	{
+		s = SZ(ip6t_entry);
+
+		for (m = r->matches; m; m = m->next)
+			s += SZ(ip6t_entry_match) + m->match->size;
+
+		s += SZ(ip6t_entry_target);
+		if (r->target)
+			s += r->target->size;
+
+		mask = fw3_alloc(s);
+		memset(mask, 0xFF, SZ(ip6t_entry));
+		p = mask + SZ(ip6t_entry);
+
+		for (m = r->matches; m; m = m->next)
+		{
+			memset(p, 0xFF, SZ(ip6t_entry_match) + m->match->userspacesize);
+			p += SZ(ip6t_entry_match) + m->match->size;
+		}
+
+		memset(p, 0xFF, SZ(ip6t_entry_target) + (r->target) ? r->target->userspacesize : 0);
+	}
+	else
+#endif
+	{
+		s = SZ(ipt_entry);
+
+		for (m = r->matches; m; m = m->next)
+			s += SZ(ipt_entry_match) + m->match->size;
+
+		s += SZ(ipt_entry_target);
+		if (r->target)
+			s += r->target->size;
+
+		mask = fw3_alloc(s);
+		memset(mask, 0xFF, SZ(ipt_entry));
+		p = mask + SZ(ipt_entry);
+
+		for (m = r->matches; m; m = m->next)
+		{
+			memset(p, 0xFF, SZ(ipt_entry_match) + m->match->userspacesize);
+			p += SZ(ipt_entry_match) + m->match->size;
+		}
+
+		memset(p, 0xFF, SZ(ipt_entry_target) + (r->target) ? r->target->userspacesize : 0);
+	}
+
+	return mask;
+}
+
+static void *
+rule_build(struct fw3_ipt_rule *r)
+{
+	size_t s, target_size = (r->target) ? r->target->t->u.target_size : 0;
+	struct xtables_rule_match *m;
+
+#ifndef DISABLE_IPV6
+	if (r->h->family == FW3_FAMILY_V6)
+	{
+		struct ip6t_entry *e6;
+
+		s = XT_ALIGN(sizeof(struct ip6t_entry));
+
+		for (m = r->matches; m; m = m->next)
+			s += m->match->m->u.match_size;
+
+		e6 = fw3_alloc(s + target_size);
+
+		memcpy(e6, &r->e6, sizeof(struct ip6t_entry));
+
+		e6->target_offset = s;
+		e6->next_offset = s + target_size;
+
+		s = 0;
+
+		for (m = r->matches; m; m = m->next)
+		{
+			memcpy(e6->elems + s, m->match->m, m->match->m->u.match_size);
+			s += m->match->m->u.match_size;
+		}
+
+		if (target_size)
+			memcpy(e6->elems + s, r->target->t, target_size);
+
+		return e6;
+	}
+	else
+#endif
+	{
+		struct ipt_entry *e;
+
+		s = XT_ALIGN(sizeof(struct ipt_entry));
+
+		for (m = r->matches; m; m = m->next)
+			s += m->match->m->u.match_size;
+
+		e = fw3_alloc(s + target_size);
+
+		memcpy(e, &r->e, sizeof(struct ipt_entry));
+
+		e->target_offset = s;
+		e->next_offset = s + target_size;
+
+		s = 0;
+
+		for (m = r->matches; m; m = m->next)
+		{
+			memcpy(e->elems + s, m->match->m, m->match->m->u.match_size);
+			s += m->match->m->u.match_size;
+		}
+
+		if (target_size)
+			memcpy(e->elems + s, r->target->t, target_size);
+
+		return e;
+	}
+}
+
+static void
+set_rule_tag(struct fw3_ipt_rule *r)
+{
+	int i;
+	char *p, **tmp;
+	const char *tag = "!fw3";
+
+	for (i = 0; i < r->argc; i++)
+		if (!strcmp(r->argv[i], "--comment") && (i + 1) < r->argc)
+			if (asprintf(&p, "%s: %s", tag, r->argv[i + 1]) > 0)
+			{
+				free(r->argv[i + 1]);
+				r->argv[i + 1] = p;
+				return;
+			}
+
+	tmp = realloc(r->argv, (r->argc + 4) * sizeof(*r->argv));
+
+	if (tmp)
+	{
+		r->argv = tmp;
+		r->argv[r->argc++] = fw3_strdup("-m");
+		r->argv[r->argc++] = fw3_strdup("comment");
+		r->argv[r->argc++] = fw3_strdup("--comment");
+		r->argv[r->argc++] = fw3_strdup(tag);
+	}
+}
+
+void
+__fw3_ipt_rule_append(struct fw3_ipt_rule *r, bool repl, const char *fmt, ...)
+{
+	void *rule;
+	unsigned char *mask;
+
 	struct xtables_rule_match *m;
 	struct xtables_match *em;
 	struct xtables_target *et;
 	struct xtables_globals *g;
-	struct ipt_entry *e;
-	struct ip6t_entry *e6;
 
 	int i, optc;
 	bool inv = false;
@@ -1141,7 +1539,10 @@ fw3_ipt_rule_append(struct fw3_ipt_rule *r, const char *fmt, ...)
 	optind = 0;
 	opterr = 0;
 
-	while ((optc = getopt_long(r->argc, r->argv, "m:j:", g->opts, NULL)) != -1)
+	set_rule_tag(r);
+
+	while ((optc = getopt_long(r->argc, r->argv, "-:m:j:", g->opts,
+	                           NULL)) != -1)
 	{
 		switch (optc)
 		{
@@ -1150,8 +1551,8 @@ fw3_ipt_rule_append(struct fw3_ipt_rule *r, const char *fmt, ...)
 
 			if (!em)
 			{
-				fprintf(stderr, "fw3_ipt_rule_append(): Can't find match '%s'\n", optarg);
-				return;
+				warn("fw3_ipt_rule_append(): Can't find match '%s'", optarg);
+				goto free;
 			}
 
 			init_match(r, em, true);
@@ -1162,8 +1563,8 @@ fw3_ipt_rule_append(struct fw3_ipt_rule *r, const char *fmt, ...)
 
 			if (!et)
 			{
-				fprintf(stderr, "fw3_ipt_rule_append(): Can't find target '%s'\n", optarg);
-				return;
+				warn("fw3_ipt_rule_append(): Can't find target '%s'", optarg);
+				goto free;
 			}
 
 			break;
@@ -1171,12 +1572,13 @@ fw3_ipt_rule_append(struct fw3_ipt_rule *r, const char *fmt, ...)
 		case 1:
 			if ((optarg[0] == '!') && (optarg[1] == '\0'))
 			{
+				optarg[0] = '\0';
 				inv = true;
 				continue;
 			}
 
-			fprintf(stderr, "fw3_ipt_rule_append(): Bad argument '%s'\n", optarg);
-			return;
+			warn("fw3_ipt_rule_append(): Bad argument '%s'", optarg);
+			goto free;
 
 		default:
 			if (parse_option(r, optc, inv))
@@ -1193,65 +1595,52 @@ fw3_ipt_rule_append(struct fw3_ipt_rule *r, const char *fmt, ...)
 	if (r->target)
 		xtables_option_tfcall(r->target);
 
-	if (fw3_pr_debug)
-		rule_print(r, buf);
+	rule = rule_build(r);
 
+#ifndef DISABLE_IPV6
 	if (r->h->family == FW3_FAMILY_V6)
 	{
-		s = XT_ALIGN(sizeof(struct ip6t_entry));
-
-		for (m = r->matches; m; m = m->next)
-			s += m->match->m->u.match_size;
-
-		e6 = fw3_alloc(s + r->target->t->u.target_size);
-
-		memcpy(e6, &r->e6, sizeof(struct ip6t_entry));
-
-		e6->target_offset = s;
-		e6->next_offset = s + r->target->t->u.target_size;
+		if (repl)
+		{
+			mask = rule_mask(r);
 
-		s = 0;
+			while (ip6tc_delete_entry(buf, rule, mask, r->h->handle))
+				if (fw3_pr_debug)
+					rule_print(r, "-D", buf);
 
-		for (m = r->matches; m; m = m->next)
-		{
-			memcpy(e6->elems + s, m->match->m, m->match->m->u.match_size);
-			s += m->match->m->u.match_size;
+			free(mask);
 		}
 
-		memcpy(e6->elems + s, r->target->t, r->target->t->u.target_size);
-		ip6tc_append_entry(buf, e6, r->h->handle);
-		free(e6);
+		if (fw3_pr_debug)
+			rule_print(r, "-A", buf);
+
+		if (!ip6tc_append_entry(buf, rule, r->h->handle))
+			warn("ip6tc_append_entry(): %s", ip6tc_strerror(errno));
 	}
 	else
+#endif
 	{
-		s = XT_ALIGN(sizeof(struct ipt_entry));
-
-		for (m = r->matches; m; m = m->next)
-			s += m->match->m->u.match_size;
-
-		e = fw3_alloc(s + r->target->t->u.target_size);
-
-		memcpy(e, &r->e, sizeof(struct ipt_entry));
-
-		e->target_offset = s;
-		e->next_offset = s + r->target->t->u.target_size;
+		if (repl)
+		{
+			mask = rule_mask(r);
 
-		s = 0;
+			while (iptc_delete_entry(buf, rule, mask, r->h->handle))
+				if (fw3_pr_debug)
+					rule_print(r, "-D", buf);
 
-		for (m = r->matches; m; m = m->next)
-		{
-			memcpy(e->elems + s, m->match->m, m->match->m->u.match_size);
-			s += m->match->m->u.match_size;
+			free(mask);
 		}
 
-		memcpy(e->elems + s, r->target->t, r->target->t->u.target_size);
-
-		if (!iptc_append_entry(buf, e, r->h->handle))
-			fprintf(stderr, "iptc_append_entry(): %s\n", iptc_strerror(errno));
+		if (fw3_pr_debug)
+			rule_print(r, "-A", buf);
 
-		free(e);
+		if (!iptc_append_entry(buf, rule, r->h->handle))
+			warn("iptc_append_entry(): %s\n", iptc_strerror(errno));
 	}
 
+	free(rule);
+
+free:
 	for (i = 1; i < r->argc; i++)
 		free(r->argv[i]);
 
@@ -1259,7 +1648,9 @@ fw3_ipt_rule_append(struct fw3_ipt_rule *r, const char *fmt, ...)
 
 	xtables_rule_matches_free(&r->matches);
 
-	free(r->target->t);
+	if (r->target)
+		free(r->target->t);
+
 	free(r);
 
 	/* reset all targets and matches */
@@ -1290,3 +1681,63 @@ fw3_ipt_rule_create(struct fw3_ipt_handle *handle, struct fw3_protocol *proto,
 
 	return r;
 }
+
+void
+xtables_register_match(struct xtables_match *me)
+{
+	int i;
+	static struct xtables_match **tmp;
+
+	if (!xext.register_match)
+		xext.register_match = dlsym(RTLD_NEXT, "xtables_register_match");
+
+	if (!xext.register_match)
+		return;
+
+	xext.register_match(me);
+
+	if (xext.retain)
+	{
+		for (i = 0; i < xext.mcount; i++)
+			if (xext.matches[i] == me)
+				return;
+
+		tmp = realloc(xext.matches, sizeof(me) * (xext.mcount + 1));
+
+		if (!tmp)
+			return;
+
+		xext.matches = tmp;
+		xext.matches[xext.mcount++] = me;
+	}
+}
+
+void
+xtables_register_target(struct xtables_target *me)
+{
+	int i;
+	static struct xtables_target **tmp;
+
+	if (!xext.register_target)
+		xext.register_target = dlsym(RTLD_NEXT, "xtables_register_target");
+
+	if (!xext.register_target)
+		return;
+
+	xext.register_target(me);
+
+	if (xext.retain)
+	{
+		for (i = 0; i < xext.tcount; i++)
+			if (xext.targets[i] == me)
+				return;
+
+		tmp = realloc(xext.targets, sizeof(me) * (xext.tcount + 1));
+
+		if (!tmp)
+			return;
+
+		xext.targets = tmp;
+		xext.targets[xext.tcount++] = me;
+	}
+}