X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=tools%2Fiptables-test.c;h=a7193c2e8a30519621bf589f9e2720451724c5ed;hb=a16d6c316722e340947219de8fea6ebb3b8dce04;hp=c47961852993c8f926d1d15d22bfbdce92b78d85;hpb=09bbe2bde426efe3608cd72cdaf3d7414e434c3c;p=framework%2Fconnectivity%2Fconnman.git

diff --git a/tools/iptables-test.c b/tools/iptables-test.c
index c479618..a7193c2 100644
--- a/tools/iptables-test.c
+++ b/tools/iptables-test.c
@@ -25,6 +25,8 @@
 #include <unistd.h>
 #include <sys/errno.h>
 #include <sys/socket.h>
+#include <sys/types.h>
+#include <arpa/inet.h>
 #include <xtables.h>
 
 #include <linux/netfilter_ipv4/ip_tables.h>
@@ -76,15 +78,14 @@ static const char *hooknames[] = {
 
 #define ALIGN(s) (((s) + ((MIN_ALIGN)-1)) & ~((MIN_ALIGN)-1))
 
-struct ipt_error_target {
+struct error_target {
 	struct xt_entry_target t;
 	char error[IPT_TABLE_MAXNAMELEN];
 };
 
 struct connman_iptables_entry {
+	int offset;
 	int builtin;
-	int std_target;
-	int jump_offset;
 
 	struct ipt_entry *entry;
 };
@@ -99,6 +100,9 @@ struct connman_iptables {
 	unsigned int old_entries;
 	unsigned int size;
 
+	unsigned int underflow[NF_INET_NUMHOOKS];
+	unsigned int hook_entry[NF_INET_NUMHOOKS];
+
 	GList *entries;
 };
 
@@ -158,16 +162,41 @@ static gboolean is_builtin_target(char *target_name)
 	return FALSE;
 }
 
+static gboolean is_jump(struct connman_iptables_entry *e)
+{
+	struct xt_entry_target *target;
+
+	target = ipt_get_target(e->entry);
+
+	if (!strcmp(target->u.user.name, IPT_STANDARD_TARGET)) {
+		struct xt_standard_target *t;
+
+		t = (struct xt_standard_target *)target;
+
+		switch (t->verdict) {
+		case XT_RETURN:
+		case -NF_ACCEPT - 1:
+		case -NF_DROP - 1:
+		case -NF_QUEUE - 1:
+		case -NF_STOP - 1:
+			return false;
+
+		default:
+			return true;
+		}
+	}
+
+	return false;
+}
+
 static gboolean is_chain(struct connman_iptables *table,
 				struct connman_iptables_entry *e)
 {
-	int builtin;
 	struct ipt_entry *entry;
 	struct xt_entry_target *target;
 
 	entry = e->entry;
-	builtin = is_hook_entry(table, entry);
-	if (builtin >= 0)
+	if (e->builtin >= 0)
 		return TRUE;
 
 	target = ipt_get_target(entry);
@@ -177,22 +206,21 @@ static gboolean is_chain(struct connman_iptables *table,
 	return FALSE;
 }
 
-static GList *find_chain_tail(struct connman_iptables *table,
+static GList *find_chain_head(struct connman_iptables *table,
 				char *chain_name)
 {
-	GList *chain_head, *list;
-	struct connman_iptables_entry *head, *tail;
+	GList *list;
+	struct connman_iptables_entry *head;
 	struct ipt_entry *entry;
 	struct xt_entry_target *target;
 	int builtin;
 
-	/* First we look for the head */
 	for (list = table->entries; list; list = list->next) {
 		head = list->data;
 		entry = head->entry;
 
 		/* Buit-in chain */
-		builtin = is_hook_entry(table, entry);
+		builtin = head->builtin;
 		if (builtin >= 0 && !strcmp(hooknames[builtin], chain_name))
 			break;
 
@@ -203,15 +231,22 @@ static GList *find_chain_tail(struct connman_iptables *table,
 			break;
 	}
 
-	if (list == NULL)
-		return NULL;
+	return list;
+}
+
+static GList *find_chain_tail(struct connman_iptables *table,
+				char *chain_name)
+{
+	GList *chain_head, *list;
+	struct connman_iptables_entry *tail;
 
-	chain_head = list;
+	chain_head = find_chain_head(table, chain_name);
+	if (chain_head == NULL)
+		return NULL;
 
 	/* Then we look for the next chain */
 	for (list = chain_head->next; list; list = list->next) {
 		tail = list->data;
-		entry = tail->entry;
 
 		if (is_chain(table, tail))
 			return list;
@@ -221,10 +256,63 @@ static GList *find_chain_tail(struct connman_iptables *table,
 	return g_list_last(table->entries);
 }
 
+static void update_offsets(struct connman_iptables *table)
+{
+	GList *list, *prev;
+	struct connman_iptables_entry *entry, *prev_entry;
+
+	for (list = table->entries; list; list = list->next) {
+		entry = list->data;
+
+		if (list == table->entries) {
+			entry->offset = 0;
+
+			continue;
+		}
+
+		prev = list->prev;
+		prev_entry = prev->data;
+
+		entry->offset = prev_entry->offset +
+					prev_entry->entry->next_offset;
+	}
+}
+
+static void update_targets_reference(struct connman_iptables *table,
+				struct connman_iptables_entry *entry_before,
+				struct connman_iptables_entry *modified_entry,
+				gboolean is_removing)
+{
+	struct connman_iptables_entry *tmp;
+	struct xt_standard_target *t;
+	GList *list;
+	int offset;
+
+	offset = modified_entry->entry->next_offset;
+
+	for (list = table->entries; list; list = list->next) {
+		tmp = list->data;
+
+		if (!is_jump(tmp))
+			continue;
+
+		t = (struct xt_standard_target *)ipt_get_target(tmp->entry);
+
+		if (is_removing == TRUE) {
+			if (t->verdict >= entry_before->offset)
+				t->verdict -= offset;
+		} else {
+			if (t->verdict > entry_before->offset)
+				t->verdict += offset;
+		}
+	}
+}
+
 static int connman_add_entry(struct connman_iptables *table,
-				struct ipt_entry *entry, GList *before)
+				struct ipt_entry *entry, GList *before,
+					int builtin)
 {
-	struct connman_iptables_entry *e;
+	struct connman_iptables_entry *e, *entry_before;
 
 	if (table == NULL)
 		return -1;
@@ -234,11 +322,139 @@ static int connman_add_entry(struct connman_iptables *table,
 		return -1;
 
 	e->entry = entry;
+	e->builtin = builtin;
 
 	table->entries = g_list_insert_before(table->entries, before, e);
 	table->num_entries++;
 	table->size += entry->next_offset;
 
+	if (before == NULL) {
+		e->offset = table->size - entry->next_offset;
+
+		return 0;
+	}
+
+	entry_before = before->data;
+
+	/*
+	 * We've just appended/insterted a new entry. All references
+	 * should be bumped accordingly.
+	 */
+	update_targets_reference(table, entry_before, e, FALSE);
+
+	update_offsets(table);
+
+	return 0;
+}
+
+static int remove_table_entry(struct connman_iptables *table,
+					struct connman_iptables_entry *entry)
+{
+	int removed = 0;
+
+	table->num_entries--;
+	table->size -= entry->entry->next_offset;
+	removed = entry->entry->next_offset;
+
+	g_free(entry->entry);
+
+	table->entries = g_list_remove(table->entries, entry);
+
+	return removed;
+}
+
+static int connman_iptables_flush_chain(struct connman_iptables *table,
+						char *name)
+{
+	GList *chain_head, *chain_tail, *list, *next;
+	struct connman_iptables_entry *entry;
+	int builtin, removed = 0;
+
+	chain_head = find_chain_head(table, name);
+	if (chain_head == NULL)
+		return -EINVAL;
+
+	chain_tail = find_chain_tail(table, name);
+	if (chain_tail == NULL)
+		return -EINVAL;
+
+	entry = chain_head->data;
+	builtin = entry->builtin;
+
+	if (builtin >= 0)
+		list = chain_head;
+	else
+		list = chain_head->next;
+
+	if (list == chain_tail->prev)
+		return 0;
+
+	while (list != chain_tail->prev) {
+		entry = list->data;
+		next = g_list_next(list);
+
+		removed += remove_table_entry(table, entry);
+
+		list = next;
+	}
+
+	if (builtin >= 0) {
+		struct connman_iptables_entry *e;
+
+		entry = list->data;
+
+		entry->builtin = builtin;
+
+		table->underflow[builtin] -= removed;
+
+		for (list = chain_tail; list; list = list->next) {
+			e = list->data;
+
+			builtin = e->builtin;
+			if (builtin < 0)
+				continue;
+
+			table->hook_entry[builtin] -= removed;
+			table->underflow[builtin] -= removed;
+		}
+	}
+
+	update_offsets(table);
+
+	return 0;
+}
+
+static int connman_iptables_delete_chain(struct connman_iptables *table,
+						char *name)
+{
+	GList *chain_head, *chain_tail;
+	struct connman_iptables_entry *entry;
+
+	chain_head = find_chain_head(table, name);
+	if (chain_head == NULL)
+		return -EINVAL;
+
+	entry = chain_head->data;
+
+	/* We cannot remove builtin chain */
+	if (entry->builtin >= 0)
+		return -EINVAL;
+
+	chain_tail = find_chain_tail(table, name);
+	if (chain_tail == NULL)
+		return -EINVAL;
+
+	/* Chain must be flushed */
+	if (chain_head->next != chain_tail->prev)
+		return -EINVAL;
+
+	remove_table_entry(table, entry);
+
+	entry = chain_tail->prev->data;
+	remove_table_entry(table, entry);
+
+	update_offsets(table);
+
 	return 0;
 }
 
@@ -248,7 +464,7 @@ static int connman_iptables_add_chain(struct connman_iptables *table,
 	GList *last;
 	struct ipt_entry *entry_head;
 	struct ipt_entry *entry_return;
-	struct ipt_error_target *error;
+	struct error_target *error;
 	struct ipt_standard_target *standard;
 	u_int16_t entry_head_size, entry_return_size;
 
@@ -265,23 +481,23 @@ static int connman_iptables_add_chain(struct connman_iptables *table,
 
 	/* head entry */
 	entry_head_size = sizeof(struct ipt_entry) +
-				sizeof(struct ipt_error_target);
+				sizeof(struct error_target);
 	entry_head = g_try_malloc0(entry_head_size);
 	if (entry_head == NULL)
-		goto err;
+		goto err_head;
 
 	memset(entry_head, 0, entry_head_size);
 
 	entry_head->target_offset = sizeof(struct ipt_entry);
 	entry_head->next_offset = entry_head_size;
 
-	error = (struct ipt_error_target *) entry_head->elems;
+	error = (struct error_target *) entry_head->elems;
 	strcpy(error->t.u.user.name, IPT_ERROR_TARGET);
-	error->t.u.user.target_size = ALIGN(sizeof(struct ipt_error_target));
+	error->t.u.user.target_size = ALIGN(sizeof(struct error_target));
 	strcpy(error->error, name);
 
-	if (connman_add_entry(table, entry_head, last) < 0)
-		goto err;
+	if (connman_add_entry(table, entry_head, last, -1) < 0)
+		goto err_head;
 
 	/* tail entry */
 	entry_return_size = sizeof(struct ipt_entry) +
@@ -300,111 +516,354 @@ static int connman_iptables_add_chain(struct connman_iptables *table,
 				ALIGN(sizeof(struct ipt_standard_target));
 	standard->verdict = XT_RETURN;
 
-	if (connman_add_entry(table, entry_return, last) < 0)
+	if (connman_add_entry(table, entry_return, last, -1) < 0)
 		goto err;
 
 	return 0;
 
 err:
-	g_free(entry_head);
 	g_free(entry_return);
+err_head:
+	g_free(entry_head);
 
 	return -ENOMEM;
 }
 
 static struct ipt_entry *
-new_builtin_rule(char *target_name,
-		char *match_name, int match_argc, char **match_argv)
+new_rule(struct ipt_ip *ip, char *target_name,
+		struct xtables_target *xt_t,
+		char *match_name, struct xtables_match *xt_m)
 {
 	struct ipt_entry *new_entry;
 	size_t match_size, target_size;
-	struct xtables_match *xt_m;
-	struct xt_standard_target *target;
-
-	xt_m = NULL;
-	match_size = 0;
 
-	if (match_name) {
-		xt_m = xtables_find_match(match_name, XTF_TRY_LOAD, NULL);
-		if (xt_m == NULL)
-			return NULL;
-
-		match_size = ALIGN(sizeof(struct xt_entry_match)) + xt_m->size;
-	}
+	if (xt_m)
+		match_size = xt_m->m->u.match_size;
+	else
+		match_size = 0;
 
-	target_size = ALIGN(sizeof(struct xt_standard_target));
+	if (xt_t)
+		target_size = ALIGN(xt_t->t->u.target_size);
+	else
+		target_size = ALIGN(sizeof(struct xt_standard_target));
 
 	new_entry = g_try_malloc0(sizeof(struct ipt_entry) + target_size +
 								match_size);
 	if (new_entry == NULL)
 		return NULL;
 
+	memcpy(&new_entry->ip, ip, sizeof(struct ipt_ip));
+
 	new_entry->target_offset = sizeof(struct ipt_entry) + match_size;
 	new_entry->next_offset = sizeof(struct ipt_entry) + target_size +
 								match_size;
-
 	if (xt_m) {
 		struct xt_entry_match *entry_match;
 
 		entry_match = (struct xt_entry_match *)new_entry->elems;
-		entry_match->u.match_size = match_size;
-		strcpy(entry_match->u.user.name, xt_m->name);
-		entry_match->u.user.revision = xt_m->revision;
-		if (xt_m->init != NULL)
-			xt_m->init(entry_match);
+		memcpy(entry_match, xt_m->m, match_size);
 	}
 
-	target = (struct xt_standard_target *)(new_entry->elems + match_size);
-	strcpy(target->target.u.user.name, IPT_STANDARD_TARGET);
-	target->target.u.user.target_size =
-				ALIGN(sizeof(struct ipt_standard_target));
-	target->verdict = target_to_verdict(target_name);
+	if (xt_t) {
+		struct xt_entry_target *entry_target;
+
+		entry_target = ipt_get_target(new_entry);
+		memcpy(entry_target, xt_t->t, target_size);
+	}
 
 	return new_entry;
 }
 
-static struct ipt_entry *
-new_custom_rule(char *target_name, int target_argc, char **target_argv,
-		char *match_name, int match_argc, char **match_argv)
+static void update_hooks(struct connman_iptables *table, GList *chain_head,
+				struct ipt_entry *entry)
 {
-	return NULL;
+	GList *list;
+	struct connman_iptables_entry *head, *e;
+	int builtin;
+
+	if (chain_head == NULL)
+		return;
+
+	head = chain_head->data;
+
+	builtin = head->builtin;
+	if (builtin < 0)
+		return;
+
+	table->underflow[builtin] += entry->next_offset;
+
+	for (list = chain_head->next; list; list = list->next) {
+		e = list->data;
+
+		builtin = e->builtin;
+		if (builtin < 0)
+			continue;
+
+		table->hook_entry[builtin] += entry->next_offset;
+		table->underflow[builtin] += entry->next_offset;
+	}
 }
 
-static struct ipt_entry *
-new_rule(char *target_name, int target_argc, char **target_argv,
-		char *match_name, int match_argc, char **match_argv)
+static struct ipt_entry *prepare_rule_inclusion(struct connman_iptables *table,
+				struct ipt_ip *ip, char *chain_name,
+				char *target_name, struct xtables_target *xt_t,
+				char *match_name, struct xtables_match *xt_m,
+				int *builtin)
 {
+	GList *chain_tail, *chain_head;
 	struct ipt_entry *new_entry;
+	struct connman_iptables_entry *head;
 
-	if (is_builtin_target(target_name))
-		new_entry = new_builtin_rule(target_name,
-					match_name, match_argc, match_argv);
-	else
-		new_entry = new_custom_rule(target_name,
-					target_argc, target_argv,
-					match_name, match_argc, match_argv);
+	chain_head = find_chain_head(table, chain_name);
+	if (chain_head == NULL)
+		return NULL;
+
+	chain_tail = find_chain_tail(table, chain_name);
+	if (chain_tail == NULL)
+		return NULL;
+
+	new_entry = new_rule(ip, target_name, xt_t, match_name, xt_m);
+	if (new_entry == NULL)
+		return NULL;
+
+	update_hooks(table, chain_head, new_entry);
+
+	/*
+	 * If the chain is builtin, and does not have any rule,
+	 * then the one that we're inserting is becoming the head
+	 * and thus needs the builtin flag.
+	 */
+	head = chain_head->data;
+	if (head->builtin < 0)
+		*builtin = -1;
+	else if (chain_head == chain_tail->prev) {
+		*builtin = head->builtin;
+		head->builtin = -1;
+	}
 
 	return new_entry;
 }
 
 static int
-connman_iptables_add_rule(struct connman_iptables *table, char *chain_name,
-			char *target_name, int target_argc, char **target_argv,
-			char *match_name, int match_argc, char **match_argv)
+connman_iptables_append_rule(struct connman_iptables *table,
+				struct ipt_ip *ip, char *chain_name,
+				char *target_name, struct xtables_target *xt_t,
+				char *match_name, struct xtables_match *xt_m)
 {
 	GList *chain_tail;
 	struct ipt_entry *new_entry;
+	int builtin = -1, ret;
 
 	chain_tail = find_chain_tail(table, chain_name);
 	if (chain_tail == NULL)
 		return -EINVAL;
 
-	new_entry = new_rule(target_name, target_argc, target_argv,
-				match_name, match_argc, match_argv);
+	new_entry = prepare_rule_inclusion(table, ip, chain_name,
+			target_name, xt_t, match_name, xt_m, &builtin);
+	if (new_entry == NULL)
+		return -EINVAL;
+
+	ret = connman_add_entry(table, new_entry, chain_tail->prev, builtin);
+	if (ret < 0)
+		g_free(new_entry);
+
+	return ret;
+}
+
+static int connman_iptables_insert_rule(struct connman_iptables *table,
+				struct ipt_ip *ip, char *chain_name,
+				char *target_name, struct xtables_target *xt_t,
+				char *match_name, struct xtables_match *xt_m)
+{
+	GList *chain_head;
+	struct ipt_entry *new_entry;
+	int builtin = -1, ret;
+
+	chain_head = find_chain_head(table, chain_name);
+	if (chain_head == NULL)
+		return -EINVAL;
+
+	new_entry = prepare_rule_inclusion(table, ip, chain_name,
+			target_name, xt_t, match_name, xt_m, &builtin);
 	if (new_entry == NULL)
 		return -EINVAL;
 
-	return connman_add_entry(table, new_entry, chain_tail->prev);
+	ret = connman_add_entry(table, new_entry, chain_head->next, builtin);
+	if (ret < 0)
+		g_free(new_entry);
+
+	return ret;
+}
+
+static gboolean is_same_ipt_entry(struct ipt_entry *i_e1,
+					struct ipt_entry *i_e2)
+{
+	if (memcmp(&i_e1->ip, &i_e2->ip, sizeof(struct ipt_ip)) != 0)
+		return FALSE;
+
+	if (i_e1->target_offset != i_e2->target_offset)
+		return FALSE;
+
+	if (i_e1->next_offset != i_e2->next_offset)
+		return FALSE;
+
+	return TRUE;
+}
+
+static gboolean is_same_target(struct xt_entry_target *xt_e_t1,
+					struct xt_entry_target *xt_e_t2)
+{
+	if (xt_e_t1 == NULL || xt_e_t2 == NULL)
+		return FALSE;
+
+	if (strcmp(xt_e_t1->u.user.name, IPT_STANDARD_TARGET) == 0) {
+		struct xt_standard_target *xt_s_t1;
+		struct xt_standard_target *xt_s_t2;
+
+		xt_s_t1 = (struct xt_standard_target *) xt_e_t1;
+		xt_s_t2 = (struct xt_standard_target *) xt_e_t2;
+
+		if (xt_s_t1->verdict != xt_s_t2->verdict)
+			return FALSE;
+	} else {
+		if (xt_e_t1->u.target_size != xt_e_t2->u.target_size)
+			return FALSE;
+
+		if (strcmp(xt_e_t1->u.user.name, xt_e_t2->u.user.name) != 0)
+			return FALSE;
+	}
+
+	return TRUE;
+}
+
+static gboolean is_same_match(struct xt_entry_match *xt_e_m1,
+				struct xt_entry_match *xt_e_m2)
+{
+	if (xt_e_m1 == NULL || xt_e_m2 == NULL)
+		return FALSE;
+
+	if (xt_e_m1->u.match_size != xt_e_m2->u.match_size)
+		return FALSE;
+
+	if (xt_e_m1->u.user.revision != xt_e_m2->u.user.revision)
+		return FALSE;
+
+	if (strcmp(xt_e_m1->u.user.name, xt_e_m2->u.user.name) != 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+static int connman_iptables_delete_rule(struct connman_iptables *table,
+				struct ipt_ip *ip, char *chain_name,
+				char *target_name, struct xtables_target *xt_t,
+				char *match_name, struct xtables_match *xt_m)
+{
+	GList *chain_tail, *chain_head, *list;
+	struct xt_entry_target *xt_e_t = NULL;
+	struct xt_entry_match *xt_e_m = NULL;
+	struct connman_iptables_entry *entry;
+	struct ipt_entry *entry_test;
+	int builtin, removed;
+
+	removed = 0;
+
+	chain_head = find_chain_head(table, chain_name);
+	if (chain_head == NULL)
+		return -EINVAL;
+
+	chain_tail = find_chain_tail(table, chain_name);
+	if (chain_tail == NULL)
+		return -EINVAL;
+
+	if (!xt_t && !xt_m)
+		return -EINVAL;
+
+	entry_test = new_rule(ip, target_name, xt_t, match_name, xt_m);
+	if (entry_test == NULL)
+		return -EINVAL;
+
+	if (xt_t != NULL)
+		xt_e_t = ipt_get_target(entry_test);
+	if (xt_m != NULL)
+		xt_e_m = (struct xt_entry_match *)entry_test->elems;
+
+	entry = chain_head->data;
+	builtin = entry->builtin;
+
+	if (builtin >= 0)
+		list = chain_head;
+	else
+		list = chain_head->next;
+
+	for (entry = NULL; list != chain_tail->prev; list = list->next) {
+		struct connman_iptables_entry *tmp;
+		struct ipt_entry *tmp_e;
+
+		tmp = list->data;
+		tmp_e = tmp->entry;
+
+		if (is_same_ipt_entry(entry_test, tmp_e) == FALSE)
+			continue;
+
+		if (xt_t != NULL) {
+			struct xt_entry_target *tmp_xt_e_t;
+
+			tmp_xt_e_t = ipt_get_target(tmp_e);
+
+			if (!is_same_target(tmp_xt_e_t, xt_e_t))
+				continue;
+		}
+
+		if (xt_m != NULL) {
+			struct xt_entry_match *tmp_xt_e_m;
+
+			tmp_xt_e_m = (struct xt_entry_match *)tmp_e->elems;
+
+			if (!is_same_match(tmp_xt_e_m, xt_e_m))
+				continue;
+		}
+
+		entry = tmp;
+		break;
+	}
+
+	if (entry == NULL) {
+		g_free(entry_test);
+		return -EINVAL;
+	}
+
+	/* We have deleted a rule,
+	 * all references should be bumped accordingly */
+	if (list->next != NULL)
+		update_targets_reference(table, list->next->data,
+						list->data, TRUE);
+
+	removed += remove_table_entry(table, entry);
+
+	if (builtin >= 0) {
+		list = list->next;
+		if (list) {
+			entry = list->data;
+			entry->builtin = builtin;
+		}
+
+		table->underflow[builtin] -= removed;
+		for (list = chain_tail; list; list = list->next) {
+			entry = list->data;
+
+			builtin = entry->builtin;
+			if (builtin < 0)
+				continue;
+
+			table->hook_entry[builtin] -= removed;
+			table->underflow[builtin] -= removed;
+		}
+	}
+
+	update_offsets(table);
+
+	return 0;
 }
 
 static struct ipt_replace *
@@ -422,7 +881,7 @@ connman_iptables_blob(struct connman_iptables *table)
 	memset(r, 0, sizeof(*r) + table->size);
 
 	r->counters = g_try_malloc0(sizeof(struct xt_counters)
-				* table->num_entries);
+				* table->old_entries);
 	if (r->counters == NULL) {
 		g_free(r);
 		return NULL;
@@ -435,10 +894,8 @@ connman_iptables_blob(struct connman_iptables *table)
 	r->num_counters = table->old_entries;
 	r->valid_hooks  = table->info->valid_hooks;
 
-	memcpy(r->hook_entry, table->info->hook_entry,
-				sizeof(table->info->hook_entry));
-	memcpy(r->underflow, table->info->underflow,
-				sizeof(table->info->underflow));
+	memcpy(r->hook_entry, table->hook_entry, sizeof(table->hook_entry));
+	memcpy(r->underflow, table->underflow, sizeof(table->underflow));
 
 	entry_index = (unsigned char *)r->entries;
 	for (list = table->entries; list; list = list->next) {
@@ -499,14 +956,17 @@ static void dump_target(struct connman_iptables *table,
 		if(xt_t->print != NULL)
 			xt_t->print(NULL, target, 1);
 	} else {
-		printf("\ttarget %s\n", target->u.user.name);
-
 		xt_t = xtables_find_target(target->u.user.name, XTF_TRY_LOAD);
-		if (xt_t == NULL)
+		if (xt_t == NULL) {
+			printf("\ttarget %s\n", target->u.user.name);
 			return;
+		}
 
-		if(xt_t->print != NULL)
+		if(xt_t->print != NULL) {
+			printf("\ttarget ");
 			xt_t->print(NULL, target, 1);
+			printf("\n");
+		}
 	}
 }
 
@@ -515,6 +975,9 @@ static void dump_match(struct connman_iptables *table, struct ipt_entry *entry)
 	struct xtables_match *xt_m;
 	struct xt_entry_match *match;
 
+	if (entry->elems == (unsigned char *)entry + entry->target_offset)
+		return;
+
 	match = (struct xt_entry_match *) entry->elems;
 
 	if (!strlen(match->u.user.name))
@@ -579,6 +1042,22 @@ static int connman_iptables_dump_entry(struct ipt_entry *entry,
 	return 0;
 }
 
+static void connman_iptables_dump_hook(struct connman_iptables *table)
+{
+	int i;
+	printf("hooks: \n");
+	for (i = 0; i < NF_INET_NUMHOOKS; i++) {
+		if ((table->info->valid_hooks & (1 << i)))
+			printf("%s entry %p underflow %p (%#x)\n",
+				hooknames[i],
+				table->blob_entries->entrytable +
+						table->info->hook_entry[i],
+				table->blob_entries->entrytable +
+						table->info->underflow[i],
+					table->info->underflow[i]);
+	}
+}
+
 static void connman_iptables_dump(struct connman_iptables *table)
 {
 	printf("%s valid_hooks=0x%08x, num_entries=%u, size=%u\n",
@@ -586,6 +1065,8 @@ static void connman_iptables_dump(struct connman_iptables *table)
 		table->info->valid_hooks, table->info->num_entries,
 		table->info->size);
 
+	connman_iptables_dump_hook(table);
+
 	ENTRY_ITERATE(table->blob_entries->entrytable,
 			table->blob_entries->size,
 			connman_iptables_dump_entry, table);
@@ -611,10 +1092,22 @@ static int connman_iptables_replace(struct connman_iptables *table,
 
 static void connman_iptables_cleanup(struct connman_iptables *table)
 {
+	GList *list;
+	struct connman_iptables_entry *entry;
+
 	close(table->ipt_sock);
+
+	for (list = table->entries; list; list = list->next) {
+		entry = list->data;
+
+		g_free(entry->entry);
+	}
+
 	g_free(table->info);
 	g_free(table->blob_entries);
 	g_free(table);
+
+	xtables_free_opts(1);
 }
 
 static int connman_iptables_commit(struct connman_iptables *table)
@@ -628,7 +1121,18 @@ static int connman_iptables_commit(struct connman_iptables *table)
 
 static int add_entry(struct ipt_entry *entry, struct connman_iptables *table)
 {
-	return connman_add_entry(table, entry, NULL);
+	struct ipt_entry *new_entry;
+	int builtin;
+
+	new_entry = g_try_malloc0(entry->next_offset);
+	if (new_entry == NULL)
+		return -ENOMEM;
+
+	memcpy(new_entry, entry, entry->next_offset);
+
+	builtin = is_hook_entry(table, entry);
+
+	return connman_add_entry(table, new_entry, NULL, builtin);
 }
 
 static struct connman_iptables *connman_iptables_init(const char *table_name)
@@ -669,6 +1173,11 @@ static struct connman_iptables *connman_iptables_init(const char *table_name)
 	table->old_entries = table->info->num_entries;
 	table->size = 0;
 
+	memcpy(table->underflow, table->info->underflow,
+				sizeof(table->info->underflow));
+	memcpy(table->hook_entry, table->info->hook_entry,
+				sizeof(table->info->hook_entry));
+
 	ENTRY_ITERATE(table->blob_entries->entrytable,
 			table->blob_entries->size,
 				add_entry, table);
@@ -683,68 +1192,282 @@ err:
 	return NULL;
 }
 
+static struct xtables_target *prepare_target(struct connman_iptables *table,
+							char *target_name)
+{
+	struct xtables_target *xt_t = NULL;
+	gboolean is_builtin, is_user_defined;
+	GList *chain_head = NULL;
+	size_t target_size;
+
+	is_builtin = FALSE;
+	is_user_defined = FALSE;
+
+	if (is_builtin_target(target_name))
+		is_builtin = TRUE;
+	else {
+		chain_head = find_chain_head(table, target_name);
+		if (chain_head != NULL && chain_head->next != NULL)
+			is_user_defined = TRUE;
+	}
+
+	if (is_builtin || is_user_defined)
+		xt_t = xtables_find_target(IPT_STANDARD_TARGET,
+						XTF_LOAD_MUST_SUCCEED);
+	else
+		xt_t = xtables_find_target(target_name, XTF_TRY_LOAD);
+
+	if (xt_t == NULL)
+		return NULL;
+
+	target_size = ALIGN(sizeof(struct ipt_entry_target)) + xt_t->size;
+
+	xt_t->t = g_try_malloc0(target_size);
+	if (xt_t->t == NULL)
+		return NULL;
+
+	xt_t->t->u.target_size = target_size;
+
+	if (is_builtin || is_user_defined) {
+		struct xt_standard_target *target;
+
+		target = (struct xt_standard_target *)(xt_t->t);
+		strcpy(target->target.u.user.name, IPT_STANDARD_TARGET);
+
+		if (is_builtin == TRUE)
+			target->verdict = target_to_verdict(target_name);
+		else if (is_user_defined == TRUE) {
+			struct connman_iptables_entry *target_rule;
+
+			if (chain_head == NULL) {
+				g_free(xt_t->t);
+				return NULL;
+			}
+
+			target_rule = chain_head->next->data;
+			target->verdict = target_rule->offset;
+		}
+	} else {
+		strcpy(xt_t->t->u.user.name, target_name);
+		xt_t->t->u.user.revision = xt_t->revision;
+		if (xt_t->init != NULL)
+			xt_t->init(xt_t->t);
+	}
+
+	return xt_t;
+}
 
 static struct option connman_iptables_opts[] = {
 	{.name = "append",        .has_arg = 1, .val = 'A'},
+	{.name = "delete",        .has_arg = 1, .val = 'D'},
+	{.name = "flush-chain",   .has_arg = 1, .val = 'F'},
+	{.name = "insert",        .has_arg = 1, .val = 'I'},
 	{.name = "list",          .has_arg = 2, .val = 'L'},
 	{.name = "new-chain",     .has_arg = 1, .val = 'N'},
+	{.name = "delete-chain",  .has_arg = 1, .val = 'X'},
+	{.name = "destination",   .has_arg = 1, .val = 'd'},
 	{.name = "in-interface",  .has_arg = 1, .val = 'i'},
 	{.name = "jump",          .has_arg = 1, .val = 'j'},
 	{.name = "match",         .has_arg = 1, .val = 'm'},
 	{.name = "out-interface", .has_arg = 1, .val = 'o'},
+	{.name = "source",        .has_arg = 1, .val = 's'},
 	{.name = "table",         .has_arg = 1, .val = 't'},
 	{NULL},
 };
 
+struct xtables_globals connman_iptables_globals = {
+	.option_offset = 0,
+	.opts = connman_iptables_opts,
+	.orig_opts = connman_iptables_opts,
+};
+
 int main(int argc, char *argv[])
 {
 	struct connman_iptables *table;
+	struct xtables_match *xt_m;
+	struct xtables_target *xt_t;
+	struct ipt_ip ip;
 	char *table_name, *chain, *new_chain, *match_name, *target_name;
-	int c;
-	gboolean dump;
+	char *delete_chain, *flush_chain;
+	int c, in_len, out_len;
+	size_t size;
+	gboolean dump, invert, delete, insert, delete_rule;
+	struct in_addr src, dst;
 
-	xtables_init();
-	xtables_set_nfproto(NFPROTO_IPV4);
+	xtables_init_all(&connman_iptables_globals, NFPROTO_IPV4);
 
 	dump = FALSE;
+	invert = FALSE;
+	delete = FALSE;
+	insert = FALSE;
+	delete_rule = FALSE;
 	table_name = chain = new_chain = match_name = target_name = NULL;
+	delete_chain = flush_chain = NULL;
+	memset(&ip, 0, sizeof(struct ipt_ip));
+	table = NULL;
+	xt_m = NULL;
+	xt_t = NULL;
 
-	while ((c = getopt_long(argc, argv,
-	   "-A:L::N:j:i:m:o:t:", connman_iptables_opts, NULL)) != -1) {
+	while ((c = getopt_long(argc, argv, "-A:D:F:I:L::N:X:d:i:j:m:o:s:t:",
+				connman_iptables_globals.opts, NULL)) != -1) {
 		switch (c) {
 		case 'A':
+			/* It is either -A, -D or -I at once */
+			if (chain)
+				goto out;
+
+			chain = optarg;
+			break;
+
+		case 'D':
+			/* It is either -A, -D or -I at once */
+			if (chain)
+				goto out;
+
+			chain = optarg;
+			delete_rule = TRUE;
+			break;
+
+		case 'F':
+			flush_chain = optarg;
+			break;
+
+		case 'I':
+			/* It is either -A, -D or -I at once */
+			if (chain)
+				goto out;
+
 			chain = optarg;
+			insert = TRUE;
 			break;
 
 		case 'L':
-			dump = TRUE;
+			dump = true;
 			break;
 
 		case 'N':
 			new_chain = optarg;
 			break;
 
-		case 'j':
-			target_name = optarg;
+		case 'X':
+			delete = true;
+			delete_chain = optarg;
+			break;
+
+		case 'd':
+			if (!inet_pton(AF_INET, optarg, &dst))
+				break;
+
+			ip.dst = dst;
+			inet_pton(AF_INET, "255.255.255.255", &ip.dmsk);
+
+			if (invert)
+				ip.invflags |= IPT_INV_DSTIP;
+
 			break;
 
 		case 'i':
+			in_len = strlen(optarg);
+
+			if (in_len + 1 > IFNAMSIZ)
+				break;
+
+			strcpy(ip.iniface, optarg);
+			memset(ip.iniface_mask, 0xff, in_len + 1);
+
+			if (invert)
+				ip.invflags |= IPT_INV_VIA_IN;
+
+			break;
+
+		case 'j':
+			target_name = optarg;
 			break;
 
 		case 'm':
 			match_name = optarg;
+
+			xt_m = xtables_find_match(optarg, XTF_LOAD_MUST_SUCCEED, NULL);
+			size = ALIGN(sizeof(struct ipt_entry_match)) + xt_m->size;
+			xt_m->m = g_try_malloc0(size);
+			if (xt_m == NULL)
+				goto out;
+			xt_m->m->u.match_size = size;
+			strcpy(xt_m->m->u.user.name, xt_m->name);
+			xt_m->m->u.user.revision = xt_m->revision;
+			if (xt_m->init != NULL)
+				xt_m->init(xt_m->m);
+			if (xt_m != xt_m->next) {
+				connman_iptables_globals.opts =
+					xtables_merge_options(
+#if XTABLES_VERSION_CODE > 5
+						connman_iptables_globals.orig_opts,
+#endif
+						connman_iptables_globals.opts,
+						xt_m->extra_opts,
+						&xt_m->option_offset);
+				if (connman_iptables_globals.opts == NULL)
+					goto out;
+			}
+
 			break;
 
 		case 'o':
+			out_len = strlen(optarg);
+
+			if (out_len + 1 > IFNAMSIZ)
+				break;
+
+			strcpy(ip.outiface, optarg);
+			memset(ip.outiface_mask, 0xff, out_len + 1);
+
+			if (invert)
+				ip.invflags |= IPT_INV_VIA_OUT;
+
+			break;
+
+		case 's':
+			if (!inet_pton(AF_INET, optarg, &src))
+				break;
+
+			ip.src = src;
+			inet_pton(AF_INET, "255.255.255.255", &ip.smsk);
+
+			if (invert)
+				ip.invflags |= IPT_INV_SRCIP;
+
 			break;
 
 		case 't':
 			table_name = optarg;
 			break;
 
+		case 1:
+			if (optarg[0] == '!' && optarg[1] == '\0') {
+				if (invert)
+					printf("Consecutive ! not allowed\n");
+
+				invert = TRUE;
+				optarg[0] = '\0';
+				continue;
+			}
+
+			printf("Invalid option\n");
+
+			return -1;
+
 		default:
-			printf("default %s\n", optarg);
+			if (xt_t == NULL || xt_t->parse == NULL ||
+			    !xt_t->parse(c - xt_t->option_offset, argv, invert,
+					&xt_t->tflags, NULL, &xt_t->t)) {
+				if (xt_m == NULL || xt_m->parse == NULL)
+					break;
+
+				xt_m->parse(c - xt_m->option_offset, argv,
+					invert, &xt_m->mflags, NULL, &xt_m->m);
+			}
 
+			break;
 		}
 	}
 
@@ -755,6 +1478,25 @@ int main(int argc, char *argv[])
 	if (table == NULL)
 		return -1;
 
+	if (delete) {
+		if (delete_chain == NULL)
+			goto out;
+
+		printf("Delete chain %s\n", delete_chain);
+
+		connman_iptables_delete_chain(table, delete_chain);
+
+		goto commit;
+	}
+
+	if (flush_chain) {
+		printf("Flush chain %s\n", flush_chain);
+
+		connman_iptables_flush_chain(table, flush_chain);
+
+		goto commit;
+	}
+
 	if (dump) {
 		connman_iptables_dump(table);
 
@@ -773,23 +1515,58 @@ int main(int argc, char *argv[])
 	}
 
 	if (chain) {
-		if (target_name == NULL)
-			return -1;
+		xt_t = prepare_target(table, target_name);
+		if (xt_t == NULL)
+			goto out;
+
+		connman_iptables_globals.opts =
+			xtables_merge_options(
+#if XTABLES_VERSION_CODE > 5
+					connman_iptables_globals.orig_opts,
+#endif
+					connman_iptables_globals.opts,
+					xt_t->extra_opts,
+					&xt_t->option_offset);
+		if (connman_iptables_globals.opts == NULL)
+			goto out;
+
+		if (delete_rule == TRUE) {
+			printf("Deleting %s to %s (match %s)\n", target_name,
+					chain, match_name);
+
+			connman_iptables_delete_rule(table, &ip, chain,
+					target_name, xt_t, match_name, xt_m);
+
+			goto commit;
+		}
 
-		printf("Adding %s to %s (match %s)\n", target_name, chain, match_name);
+		if (insert == TRUE) {
+			printf("Inserting %s to %s (match %s)\n", target_name,
+					chain, match_name);
 
-		connman_iptables_add_rule(table, chain,
-					target_name, 0, NULL,
-					match_name, 0, NULL);
+			connman_iptables_insert_rule(table, &ip, chain,
+					target_name, xt_t, match_name, xt_m);
+		} else {
+			printf("Appending %s to %s (match %s)\n", target_name,
+					chain, match_name);
 
-		goto commit;
+			connman_iptables_append_rule(table, &ip, chain,
+				target_name, xt_t, match_name, xt_m);
+		}
 	}
 
 commit:
 
 	connman_iptables_commit(table);
 
+out:
 	connman_iptables_cleanup(table);
 
+	if (xt_t)
+		g_free(xt_t->t);
+
+	if (xt_m)
+		g_free(xt_m->m);
+
 	return 0;
 }