*
* Connection Manager
*
- * Copyright (C) 2007-2011 Intel Corporation. All rights reserved.
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
*
* 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
#define LABEL_QUEUE "QUEUE"
#define LABEL_RETURN "RETURN"
+#define XT_OPTION_OFFSET_SCALE 256
+
/* fn returns 0 to continue iteration */
#define _XT_ENTRY_ITERATE_CONTINUE(type, entries, size, n, fn, args...) \
({ \
static struct ipt_entry *new_rule(struct ipt_ip *ip,
char *target_name, struct xtables_target *xt_t,
- char *match_name, struct xtables_match *xt_m)
+ struct xtables_rule_match *xt_rm)
{
+ struct xtables_rule_match *tmp_xt_rm;
struct ipt_entry *new_entry;
size_t match_size, target_size;
- if (xt_m)
- match_size = xt_m->m->u.match_size;
- else
- match_size = 0;
+ match_size = 0;
+ for (tmp_xt_rm = xt_rm; tmp_xt_rm != NULL; tmp_xt_rm = tmp_xt_rm->next)
+ match_size += tmp_xt_rm->match->m->u.match_size;
if (xt_t)
target_size = ALIGN(xt_t->t->u.target_size);
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;
- memcpy(entry_match, xt_m->m, match_size);
+ match_size = 0;
+ for (tmp_xt_rm = xt_rm; tmp_xt_rm != NULL;
+ tmp_xt_rm = tmp_xt_rm->next) {
+ memcpy(new_entry->elems + match_size, tmp_xt_rm->match->m,
+ tmp_xt_rm->match->m->u.match_size);
+ match_size += tmp_xt_rm->match->m->u.match_size;
}
if (xt_t) {
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)
+ int *builtin, struct xtables_rule_match *xt_rm)
{
GList *chain_tail, *chain_head;
struct ipt_entry *new_entry;
if (chain_tail == NULL)
return NULL;
- new_entry = new_rule(ip, target_name, xt_t, match_name, xt_m);
+ new_entry = new_rule(ip, target_name, xt_t, xt_rm);
if (new_entry == NULL)
return NULL;
static int 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)
+ struct xtables_rule_match *xt_rm)
{
GList *chain_tail;
struct ipt_entry *new_entry;
return -EINVAL;
new_entry = prepare_rule_inclusion(table, ip, chain_name,
- target_name, xt_t, match_name, xt_m, &builtin);
+ target_name, xt_t, &builtin, xt_rm);
if (new_entry == NULL)
return -EINVAL;
static int 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)
+ struct xtables_rule_match *xt_rm)
{
struct ipt_entry *new_entry;
int builtin = -1, ret;
return -EINVAL;
new_entry = prepare_rule_inclusion(table, ip, chain_name,
- target_name, xt_t, match_name, xt_m, &builtin);
+ target_name, xt_t, &builtin, xt_rm);
if (new_entry == NULL)
return -EINVAL;
- ret = iptables_add_entry(table, new_entry, chain_head->next, builtin);
+ if (builtin == -1)
+ chain_head = chain_head->next;
+
+ ret = iptables_add_entry(table, new_entry, chain_head, builtin);
if (ret < 0)
g_free(new_entry);
return TRUE;
}
-static int iptables_delete_rule(struct connman_iptables *table,
+static GList *find_existing_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)
+ struct xtables_match *xt_m,
+ struct xtables_rule_match *xt_rm)
{
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;
+ int builtin;
chain_head = find_chain_head(table, chain_name);
if (chain_head == NULL)
- return -EINVAL;
+ return NULL;
chain_tail = find_chain_tail(table, chain_name);
if (chain_tail == NULL)
- return -EINVAL;
+ return NULL;
if (!xt_t && !xt_m)
- return -EINVAL;
+ return NULL;
- entry_test = new_rule(ip, target_name, xt_t, match_name, xt_m);
+ entry_test = new_rule(ip, target_name, xt_t, xt_rm);
if (entry_test == NULL)
- return -EINVAL;
+ return NULL;
if (xt_t != NULL)
xt_e_t = ipt_get_target(entry_test);
else
list = chain_head->next;
- for (entry = NULL; list != chain_tail->prev; list = list->next) {
+ for (; list != chain_tail->prev; list = list->next) {
struct connman_iptables_entry *tmp;
struct ipt_entry *tmp_e;
continue;
}
- entry = tmp;
break;
}
- if (entry == NULL) {
- g_free(entry_test);
+ g_free(entry_test);
+
+ if (list != chain_tail->prev)
+ return list;
+
+ return NULL;
+}
+
+static int iptables_delete_rule(struct connman_iptables *table,
+ struct ipt_ip *ip, char *chain_name,
+ char *target_name, struct xtables_target *xt_t,
+ struct xtables_match *xt_m,
+ struct xtables_rule_match *xt_rm)
+{
+ struct connman_iptables_entry *entry;
+ GList *chain_tail, *list;
+ int builtin, removed;
+
+ removed = 0;
+
+ chain_tail = find_chain_tail(table, chain_name);
+ if (chain_tail == NULL)
return -EINVAL;
- }
+
+ list = find_existing_rule(table, ip, chain_name, target_name,
+ xt_t, xt_m, xt_rm);
+ if (list == NULL)
+ return -EINVAL;
+
+ entry = list->data;
+ if (entry == NULL)
+ return -EINVAL;
+
+ builtin = entry->builtin;
/* We have deleted a rule,
* all references should be bumped accordingly */
return 0;
}
+static int iptables_compare_rule(struct connman_iptables *table,
+ struct ipt_ip *ip, char *chain_name,
+ char *target_name, struct xtables_target *xt_t,
+ struct xtables_match *xt_m,
+ struct xtables_rule_match *xt_rm)
+{
+ struct connman_iptables_entry *entry;
+ GList *found;
+
+ found = find_existing_rule(table, ip, chain_name, target_name,
+ xt_t, xt_m, xt_rm);
+ if (found == NULL)
+ return -EINVAL;
+
+ entry = found->data;
+ if (entry == NULL)
+ return -EINVAL;
+
+ return 0;
+}
+
+
+static int iptables_change_policy(struct connman_iptables *table,
+ char *chain_name, char *policy)
+{
+ GList *chain_head;
+ struct connman_iptables_entry *entry;
+ struct xt_entry_target *target;
+ struct xt_standard_target *t;
+ int verdict;
+
+ verdict = target_to_verdict(policy);
+ if (verdict == 0)
+ return -EINVAL;
+
+ chain_head = find_chain_head(table, chain_name);
+ if (chain_head == NULL)
+ return -EINVAL;
+
+ entry = chain_head->data;
+ if (entry->builtin < 0)
+ return -EINVAL;
+
+ target = ipt_get_target(entry->entry);
+
+ t = (struct xt_standard_target *)target;
+ t->verdict = verdict;
+
+ return 0;
+}
+
static struct ipt_replace *iptables_blob(struct connman_iptables *table)
{
struct ipt_replace *r;
GList *list;
struct connman_iptables_entry *entry;
+ if (table == NULL)
+ return;
+
close(table->ipt_sock);
for (list = table->entries; list; list = list->next) {
DBG("%s", table_name);
if (xtables_insmod("ip_tables", NULL, TRUE) != 0)
- goto err;
+ return NULL;
module = g_strconcat("iptable_", table_name, NULL);
if (module == NULL)
- goto err;
+ return NULL;
- if (xtables_insmod(module, NULL, TRUE) != 0)
- goto err;
+ if (xtables_insmod(module, NULL, TRUE) != 0) {
+ g_free(module);
+ return NULL;
+ }
g_free(module);
- module = NULL;
table = g_hash_table_lookup(table_hash, table_name);
if (table != NULL)
return table;
err:
- g_free(module);
-
table_cleanup(table);
return NULL;
static struct option iptables_opts[] = {
{.name = "append", .has_arg = 1, .val = 'A'},
+ {.name = "compare", .has_arg = 1, .val = 'C'},
{.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 = "policy", .has_arg = 1, .val = 'P'},
{.name = "delete-chain", .has_arg = 1, .val = 'X'},
{.name = "destination", .has_arg = 1, .val = 'd'},
{.name = "in-interface", .has_arg = 1, .val = 'i'},
xt_t->init(xt_t->t);
}
- iptables_globals.opts =
- xtables_merge_options(
+#if XTABLES_VERSION_CODE > 5
+ if (xt_t->x6_options != NULL)
+ iptables_globals.opts =
+ xtables_options_xfrm(
+ iptables_globals.orig_opts,
+ iptables_globals.opts,
+ xt_t->x6_options,
+ &xt_t->option_offset);
+ else
+#endif
+ iptables_globals.opts =
+ xtables_merge_options(
#if XTABLES_VERSION_CODE > 5
iptables_globals.orig_opts,
#endif
if (xt_m->init != NULL)
xt_m->init(xt_m->m);
- if (xt_m != xt_m->next) {
+ if (xt_m == xt_m->next)
+ goto done;
+
+#if XTABLES_VERSION_CODE > 5
+ if (xt_m->x6_options != NULL)
iptables_globals.opts =
+ xtables_options_xfrm(
+ iptables_globals.orig_opts,
+ iptables_globals.opts,
+ xt_m->x6_options,
+ &xt_m->option_offset);
+ else
+#endif
+ iptables_globals.opts =
xtables_merge_options(
#if XTABLES_VERSION_CODE > 5
iptables_globals.orig_opts,
xt_m->extra_opts,
&xt_m->option_offset);
- if (iptables_globals.opts == NULL) {
- g_free(xt_m->m);
- xt_m = NULL;
- }
+ if (iptables_globals.opts == NULL) {
+ g_free(xt_m->m);
+ xt_m = NULL;
}
+done:
return xt_m;
}
+static int parse_ip_and_mask(const char *str, struct in_addr *ip, struct in_addr *mask)
+{
+ char **tokens;
+ uint32_t prefixlength;
+ uint32_t tmp;
+ int err;
+
+ tokens = g_strsplit(str, "/", 2);
+ if (tokens == NULL)
+ return -1;
+
+ if (!inet_pton(AF_INET, tokens[0], ip)) {
+ err = -1;
+ goto out;
+ }
+
+ if (tokens[1] != NULL) {
+ prefixlength = strtol(tokens[1], NULL, 10);
+ if (prefixlength > 31) {
+ err = -1;
+ goto out;
+ }
+
+ tmp = ~(0xffffffff >> prefixlength);
+ } else {
+ tmp = 0xffffffff;
+ }
+
+ mask->s_addr = htonl(tmp);
+ ip->s_addr = ip->s_addr & mask->s_addr;
+ err = 0;
+out:
+ g_strfreev(tokens);
+
+ return err;
+}
+
static int iptables_command(int argc, char *argv[])
{
struct connman_iptables *table;
- struct xtables_rule_match *xt_rm;
- struct xtables_match *xt_m;
+ struct xtables_rule_match *xt_rm, *tmp_xt_rm;
+ struct xtables_match *xt_m, *xt_m_t;
struct xtables_target *xt_t;
struct ipt_ip ip;
char *table_name, *chain, *new_chain, *match_name, *target_name;
- char *flush_chain, *delete_chain;
+ char *flush_chain, *delete_chain, *policy;
int c, ret, in_len, out_len;
- gboolean dump, invert, insert, delete;
- struct in_addr src, dst;
+ gboolean dump, invert, insert, delete, compare;
if (argc == 0)
return -EINVAL;
invert = FALSE;
insert = FALSE;
delete = FALSE;
- table_name = chain = new_chain = match_name = target_name = NULL;
- flush_chain = delete_chain = NULL;
+ compare = FALSE;
+ chain = new_chain = match_name = target_name = NULL;
+ flush_chain = delete_chain = policy = NULL;
memset(&ip, 0, sizeof(struct ipt_ip));
table = NULL;
xt_rm = NULL;
xt_t = NULL;
ret = 0;
+ /* extension's options will generate false-positives errors */
+ opterr = 0;
+
optind = 0;
- while ((c = getopt_long(argc, argv, "-A:F:I:L::N:X:d:j:i:m:o:s:t:",
+ while ((c = getopt_long(argc, argv,
+ "-A:C:D:F:I:L::N:P:X:d:j:i:m:o:s:t:",
iptables_globals.opts, NULL)) != -1) {
switch (c) {
case 'A':
- /* It is either -A, -D or -I at once */
+ /* It is either -A, -C, -D or -I at once */
if (chain)
goto out;
chain = optarg;
break;
+ case 'C':
+ /* It is either -A, -C, -D or -I at once */
+ if (chain)
+ goto out;
+
+ chain = optarg;
+ compare = TRUE;
+ break;
+
case 'D':
- /* It is either -A, -D or -I at once */
+ /* It is either -A, -C, -D or -I at once */
if (chain)
goto out;
break;
case 'I':
- /* It is either -A, -D or -I at once */
+ /* It is either -A, -C, -D or -I at once */
if (chain)
goto out;
new_chain = optarg;
break;
+ case 'P':
+ chain = optarg;
+ if (optind < argc)
+ policy = argv[optind++];
+ else
+ goto out;
+
+ break;
+
case 'X':
delete_chain = optarg;
break;
case 'd':
- if (!inet_pton(AF_INET, optarg, &dst))
+ if (!parse_ip_and_mask(optarg, &ip.dst, &ip.dmsk))
break;
- ip.dst = dst;
- inet_pton(AF_INET, "255.255.255.255", &ip.dmsk);
-
if (invert)
ip.invflags |= IPT_INV_DSTIP;
case 'j':
target_name = optarg;
+ xt_t = prepare_target(table, target_name);
+ if (xt_t == NULL)
+ goto out;
+
break;
case 'm':
match_name = optarg;
+ xt_m = prepare_matches(table, &xt_rm, match_name);
+ if (xt_m == NULL)
+ goto out;
+
break;
case 'o':
break;
case 's':
- if (!inet_pton(AF_INET, optarg, &src))
+ if (!parse_ip_and_mask(optarg, &ip.src, &ip.smsk))
break;
- ip.src = src;
- inet_pton(AF_INET, "255.255.255.255", &ip.smsk);
-
if (invert)
ip.invflags |= IPT_INV_SRCIP;
case 't':
table_name = optarg;
+
+ table = iptables_init(table_name);
+ if (table == NULL) {
+ ret = -EINVAL;
+ goto out;
+ }
+
break;
case 1:
goto out;
default:
- 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;
+#if XTABLES_VERSION_CODE > 5
+ if (xt_t != NULL && (xt_t->x6_parse != NULL ||
+ xt_t->parse != NULL) &&
+ (c >= (int) xt_t->option_offset &&
+ c < (int) xt_t->option_offset +
+ XT_OPTION_OFFSET_SCALE)) {
+ xtables_option_tpcall(c, argv,
+ invert, xt_t, NULL);
- xt_m->parse(c - xt_m->option_offset, argv,
- invert, &xt_m->mflags, NULL, &xt_m->m);
+ break;
}
+ for (tmp_xt_rm = xt_rm; tmp_xt_rm != NULL;
+ tmp_xt_rm = tmp_xt_rm->next) {
+ xt_m_t = tmp_xt_rm->match;
+
+ if (tmp_xt_rm->completed ||
+ (xt_m_t->x6_parse == NULL &&
+ xt_m_t->parse == NULL))
+ continue;
+
+ if (c < (int) xt_m_t->option_offset ||
+ c >= (int) xt_m_t->option_offset
+ + XT_OPTION_OFFSET_SCALE)
+ continue;
+
+ xtables_option_mpcall(c, argv,
+ invert, xt_m_t, NULL);
+
+ break;
+ }
+#else
+ 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)) {
+
+ for (tmp_xt_rm = xt_rm; tmp_xt_rm != NULL;
+ tmp_xt_rm = tmp_xt_rm->next) {
+ xt_m_t = tmp_xt_rm->match;
+
+ if (tmp_xt_rm->completed ||
+ xt_m_t->parse == NULL)
+ continue;
+
+ if (xt_m->parse(c - xt_m->option_offset,
+ argv, invert, &xt_m->mflags,
+ NULL, &xt_m->m))
+ break;
+ }
+ }
+#endif
break;
}
invert = FALSE;
}
- if (table_name == NULL)
- table_name = "filter";
+#if XTABLES_VERSION_CODE > 5
+ for (tmp_xt_rm = xt_rm; tmp_xt_rm != NULL;
+ tmp_xt_rm = tmp_xt_rm->next)
+ xtables_option_mfcall(tmp_xt_rm->match);
+
+ if (xt_t != NULL)
+ xtables_option_tfcall(xt_t);
+#else
+ for (tmp_xt_rm = xt_rm; tmp_xt_rm != NULL;
+ tmp_xt_rm = tmp_xt_rm->next)
+ if (tmp_xt_rm->match->final_check != NULL)
+ tmp_xt_rm->match->final_check(
+ tmp_xt_rm->match->mflags);
+
+ if (xt_t != NULL && xt_t->final_check != NULL)
+ xt_t->final_check(xt_t->tflags);
+#endif
- table = iptables_init(table_name);
if (table == NULL) {
- ret = -EINVAL;
- goto out;
+ table_name = "filter";
+
+ table = iptables_init(table_name);
+ if (table == NULL) {
+ ret = -EINVAL;
+ goto out;
+ }
}
if (delete_chain != NULL) {
}
if (chain) {
- xt_t = prepare_target(table, target_name);
+ if (policy != NULL) {
+ printf("Changing policy of %s to %s\n", chain, policy);
+
+ iptables_change_policy(table, chain, policy);
+
+ goto out;
+ }
+
if (xt_t == NULL)
goto out;
- if (match_name != NULL) {
- xt_m = prepare_matches(table, &xt_rm, match_name);
- if (xt_m == NULL)
- goto out;
+ if (compare == TRUE) {
+ ret = iptables_compare_rule(table, &ip, chain,
+ target_name, xt_t, xt_m, xt_rm);
+ goto out;
}
if (delete == TRUE) {
target_name, chain, match_name);
ret = iptables_delete_rule(table, &ip, chain,
- target_name, xt_t, match_name, xt_m);
+ target_name, xt_t, xt_m, xt_rm);
goto out;
}
target_name, chain, match_name);
ret = iptables_insert_rule(table, &ip, chain,
- target_name, xt_t, match_name, xt_m);
+ target_name, xt_t, xt_rm);
goto out;
} else {
target_name, chain, match_name);
ret = iptables_append_rule(table, &ip, chain,
- target_name, xt_t, match_name, xt_m);
+ target_name, xt_t, xt_rm);
goto out;
}