*
* 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.
+ * published by the Free Software Foundation.
*/
/* Kernel module for IP set management */
static struct list_head *ip_set_hash; /* hash of bindings */
static unsigned int ip_set_hash_random; /* random seed */
+#define SETNAME_EQ(a,b) (strncmp(a,b,IP_SET_MAXNAMELEN) == 0)
+
/*
* 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
+ * 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
+ * be deleted only from userspace. Therefore ip_set_list locking
* must obey the following rules:
*
* - kernel requests: read and write locking mandatory
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)
+ u_int32_t key = jhash_2words(id, ip, ip_set_hash_random)
% ip_set_bindings_hash_size;
struct ip_set_hash *set_hash;
set_hash = __ip_set_find(key, id, ip);
- DP("set: %s, ip: %u.%u.%u.%u, binding: %s", ip_set_list[id]->name,
+ 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
+static inline void
__set_hash_del(struct ip_set_hash *set_hash)
{
ASSERT_WRITE_LOCK(&ip_set_lock);
return 0;
}
-static int
+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_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,
+ 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 = __ip_set_find(key, id, ip);
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]
+ } while (res > 0
+ && flags[i]
&& follow_bindings(index, set, ip));
read_unlock_bh(&ip_set_lock);
write_unlock_bh(&set->lock);
i += !!(set->type->features & IPSET_DATA_DOUBLE);
} while ((res == 0 || res == -EEXIST)
- && flags[i]
+ && flags[i]
&& follow_bindings(index, set, ip));
read_unlock_bh(&ip_set_lock);
write_unlock_bh(&set->lock);
i += !!(set->type->features & IPSET_DATA_DOUBLE);
} while ((res == 0 || res == -EEXIST)
- && flags[i]
+ && flags[i]
&& follow_bindings(index, set, ip));
read_unlock_bh(&ip_set_lock);
}
return NULL;
}
-int
+int
ip_set_register_set_type(struct ip_set_type *set_type)
{
int ret = 0;
write_lock_bh(&ip_set_lock);
if (find_set_type(set_type->typename)) {
/* Duplicate! */
- ip_set_printk("'%s' already registered!",
+ ip_set_printk("'%s' already registered!",
set_type->typename);
ret = -EINVAL;
goto unlock;
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) {
+ && SETNAME_EQ(ip_set_list[i]->name, name)) {
__ip_set_get(i);
index = i;
break;
for (i = 0; i < ip_set_max; i++) {
if (ip_set_list[i] != NULL
- && strcmp(ip_set_list[i]->name, name) == 0) {
+ && SETNAME_EQ(ip_set_list[i]->name, name)) {
index = i;
break;
}
size_t size)
{
struct ip_set *set = ip_set_list[index];
- struct ip_set_req_bind *req_bind;
+ const struct ip_set_req_bind *req_bind;
ip_set_id_t binding;
ip_set_ip_t ip;
int res;
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';
+ req_bind = data;
- if (strcmp(req_bind->binding, IPSET_TOKEN_DEFAULT) == 0) {
+ if (SETNAME_EQ(req_bind->binding, IPSET_TOKEN_DEFAULT)) {
/* Default binding of a set */
- char *binding_name;
+ const 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_name = data + sizeof(struct ip_set_req_bind);
binding = ip_set_find_byname(binding_name);
if (binding == IP_SET_INVALID_ID)
size_t size)
{
struct ip_set *set;
- struct ip_set_req_bind *req_bind;
+ const struct ip_set_req_bind *req_bind;
ip_set_ip_t ip;
int res;
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';
+ req_bind = data;
DP("%u %s", index, req_bind->binding);
if (index == IP_SET_INVALID_ID) {
/* unbind :all: */
- if (strcmp(req_bind->binding, IPSET_TOKEN_DEFAULT) == 0) {
+ if (SETNAME_EQ(req_bind->binding, IPSET_TOKEN_DEFAULT)) {
/* 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) {
+ } else if (SETNAME_EQ(req_bind->binding, IPSET_TOKEN_ALL)) {
/* Flush all bindings of all sets*/
write_lock_bh(&ip_set_lock);
FOREACH_HASH_RW_DO(__set_hash_del);
set = ip_set_list[index];
IP_SET_ASSERT(set);
- if (strcmp(req_bind->binding, IPSET_TOKEN_DEFAULT) == 0) {
+ if (SETNAME_EQ(req_bind->binding, IPSET_TOKEN_DEFAULT)) {
/* Default binding of set */
ip_set_id_t binding = ip_set_find_byindex(set->binding);
write_unlock_bh(&ip_set_lock);
return 0;
- } else if (strcmp(req_bind->binding, IPSET_TOKEN_ALL) == 0) {
+ } else if (SETNAME_EQ(req_bind->binding, IPSET_TOKEN_ALL)) {
/* Flush all bindings */
write_lock_bh(&ip_set_lock);
size_t size)
{
struct ip_set *set = ip_set_list[index];
- struct ip_set_req_bind *req_bind;
+ const struct ip_set_req_bind *req_bind;
ip_set_id_t binding;
ip_set_ip_t ip;
int res;
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';
+ req_bind = data;
- if (strcmp(req_bind->binding, IPSET_TOKEN_DEFAULT) == 0) {
+ if (SETNAME_EQ(req_bind->binding, IPSET_TOKEN_DEFAULT)) {
/* Default binding of set */
- char *binding_name;
+ const 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_name = data + sizeof(struct ip_set_req_bind);
binding = ip_set_find_byname(binding_name);
if (binding == IP_SET_INVALID_ID)
&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;
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)
+ } else if (SETNAME_EQ(name, ip_set_list[i]->name))
/* Name clash */
return -EEXIST;
}
/*
* Here, we have a valid, constructed set. &ip_set_lock again,
- * find free id/index and check that it is not already in
+ * find free id/index and check that it is not already in
* ip_set_list.
*/
write_lock_bh(&ip_set_lock);
res = -ERANGE;
goto cleanup;
}
-
+
/*
* Finally! Add our shiny new set to the list, and be done.
*/
ip_set_destroy_set(index);
} else {
for (i = 0; i < ip_set_max; i++) {
- if (ip_set_list[i] != NULL
+ if (ip_set_list[i] != NULL
&& (atomic_read(&ip_set_list[i]->ref)))
return -EBUSY;
}
write_unlock_bh(&set->lock);
}
-/*
+/*
* Flush data in a set - or in all sets
*/
static int
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) {
+ && SETNAME_EQ(ip_set_list[i]->name, name)) {
res = -EEXIST;
goto unlock;
}
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);
+ struct ip_set_hash_list *hash_list = data + *used;
hash_list->ip = set_hash->ip;
hash_list->binding = set_hash->binding;
struct ip_set_list *set_list;
/* Pointer to our header */
- set_list = (struct ip_set_list *) (data + *used);
+ set_list = data + *used;
DP("set: %s, used: %d %p %p", set->name, *used, data, data + *used);
struct ip_set_save *set_save;
/* Pointer to our header */
- set_save = (struct ip_set_save *) (data + *used);
+ set_save = data + *used;
/* Get and ensure header size */
if (*used + sizeof(struct ip_set_save) > len)
*used += sizeof(struct ip_set_save);
set = ip_set_list[index];
- DP("set: %s, used: %u(%u) %p %p", set->name, *used, len,
+ DP("set: %s, used: %u(%u) %p %p", set->name, *used, len,
data, data + *used);
read_lock_bh(&set->lock);
{
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);
+ struct ip_set_hash_save *hash_save = data + *used;
/* Ensure bindings size */
if (*used + sizeof(struct ip_set_hash_save) > len) {
*res = -ENOMEM;
return -ENOMEM;
/* Marker */
- set_save = (struct ip_set_save *) (data + *used);
+ set_save = data + *used;
set_save->index = IP_SET_INVALID_ID;
set_save->header_size = 0;
set_save->members_size = 0;
/* Get and ensure header size */
if (used + sizeof(struct ip_set_restore) > len)
return line;
- set_restore = (struct ip_set_restore *) (data + used);
+ set_restore = data + used;
used += sizeof(struct ip_set_restore);
/* Ensure data size */
- if (used
- + set_restore->header_size
+ if (used
+ + set_restore->header_size
+ set_restore->members_size > len)
return line;
res = __ip_set_addip(index,
data + used + members_size,
set->type->reqsize);
- if (!(res == 0 || res == -EEXIST))
+ if (!(res == 0 || res == -EEXIST))
return line;
members_size += set->type->reqsize;
}
/* Get and ensure size */
if (used + sizeof(struct ip_set_hash_save) > len)
return line;
- hash_save = (struct ip_set_hash_save *) (data + used);
+ hash_save = data + used;
used += sizeof(struct ip_set_hash_save);
/* hash_save->id is used to store the index */
set = ip_set_list[hash_save->id];
/* Null valued IP means default binding */
if (hash_save->ip)
- res = ip_set_hash_add(set->id,
+ res = ip_set_hash_add(set->id,
hash_save->ip,
hash_save->binding);
else {
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;
+ struct ip_set_req_version *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;
+ struct ip_set_req_create *req_create = data;
if (len < sizeof(struct ip_set_req_create)) {
ip_set_printk("short CREATE data (want >=%zu, got %u)",
goto done;
}
case IP_SET_OP_DESTROY:{
- struct ip_set_req_std *req_destroy
- = (struct ip_set_req_std *) data;
+ struct ip_set_req_std *req_destroy = data;
if (len != sizeof(struct ip_set_req_std)) {
ip_set_printk("invalid DESTROY data (want %zu, got %u)",
res = -EINVAL;
goto done;
}
- if (strcmp(req_destroy->name, IPSET_TOKEN_ALL) == 0) {
+ if (SETNAME_EQ(req_destroy->name, IPSET_TOKEN_ALL)) {
/* Destroy all sets */
index = IP_SET_INVALID_ID;
} else {
goto done;
}
case IP_SET_OP_FLUSH:{
- struct ip_set_req_std *req_flush =
- (struct ip_set_req_std *) data;
+ struct ip_set_req_std *req_flush = data;
if (len != sizeof(struct ip_set_req_std)) {
ip_set_printk("invalid FLUSH data (want %zu, got %u)",
res = -EINVAL;
goto done;
}
- if (strcmp(req_flush->name, IPSET_TOKEN_ALL) == 0) {
+ if (SETNAME_EQ(req_flush->name, IPSET_TOKEN_ALL)) {
/* Flush all sets */
index = IP_SET_INVALID_ID;
} else {
goto done;
}
case IP_SET_OP_RENAME:{
- struct ip_set_req_create *req_rename
- = (struct ip_set_req_create *) data;
+ struct ip_set_req_create *req_rename = data;
if (len != sizeof(struct ip_set_req_create)) {
ip_set_printk("invalid RENAME data (want %zu, got %u)",
goto done;
}
case IP_SET_OP_SWAP:{
- struct ip_set_req_create *req_swap
- = (struct ip_set_req_create *) data;
+ struct ip_set_req_create *req_swap = data;
ip_set_id_t to_index;
if (len != sizeof(struct ip_set_req_create)) {
res = ip_set_swap(index, to_index);
goto done;
}
- default:
+ default:
break; /* Set identified by id */
}
res = -EINVAL;
goto done;
}
- req_adt = (struct ip_set_req_adt *) data;
+ req_adt = data;
/* -U :all: :all:|:default: uses IP_SET_INVALID_ID */
- if (!(*op == IP_SET_OP_UNBIND_SET
+ 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) {
return res;
}
-static int
+static int
ip_set_sockfn_get(struct sock *sk, int optval, void *user, int *len)
{
int res = 0;
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;
+ struct ip_set_req_version *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;
+ struct ip_set_req_version *req_version = data;
if (*len != sizeof(struct ip_set_req_version)) {
ip_set_printk("invalid VERSION (want %zu, got %d)",
goto done;
}
case IP_SET_OP_GET_BYNAME: {
- struct ip_set_req_get_set *req_get
- = (struct ip_set_req_get_set *) data;
+ struct ip_set_req_get_set *req_get = data;
if (*len != sizeof(struct ip_set_req_get_set)) {
ip_set_printk("invalid GET_BYNAME (want %zu, got %d)",
goto copy;
}
case IP_SET_OP_GET_BYINDEX: {
- struct ip_set_req_get_set *req_get
- = (struct ip_set_req_get_set *) data;
+ struct ip_set_req_get_set *req_get = data;
if (*len != sizeof(struct ip_set_req_get_set)) {
ip_set_printk("invalid GET_BYINDEX (want %zu, got %d)",
goto copy;
}
case IP_SET_OP_ADT_GET: {
- struct ip_set_req_adt_get *req_get
- = (struct ip_set_req_adt_get *) data;
+ struct ip_set_req_adt_get *req_get = data;
if (*len != sizeof(struct ip_set_req_adt_get)) {
ip_set_printk("invalid ADT_GET (want %zu, got %d)",
goto copy;
}
case IP_SET_OP_MAX_SETS: {
- struct ip_set_req_max_sets *req_max_sets
- = (struct ip_set_req_max_sets *) data;
+ struct ip_set_req_max_sets *req_max_sets = data;
ip_set_id_t i;
if (*len != sizeof(struct ip_set_req_max_sets)) {
goto done;
}
- if (strcmp(req_max_sets->set.name, IPSET_TOKEN_ALL) == 0) {
+ if (SETNAME_EQ(req_max_sets->set.name, IPSET_TOKEN_ALL)) {
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 =
+ 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 copy;
}
- case IP_SET_OP_LIST_SIZE:
+ 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_req_setnames *req_setnames = data;
struct ip_set_name_list *name_list;
struct ip_set *set;
ip_set_id_t i;
for (i = 0; i < ip_set_max; i++) {
if (ip_set_list[i] == NULL)
continue;
- name_list = (struct ip_set_name_list *)
- (data + used);
+ name_list = data + used;
used += sizeof(struct ip_set_name_list);
if (used > copylen) {
res = -EAGAIN;
+ set->type->header_size
+ set->type->list_members_size(set);
/* Sets are identified by id in the hash */
- FOREACH_HASH_DO(__set_hash_bindings_size_list,
+ FOREACH_HASH_DO(__set_hash_bindings_size_list,
set->id, &req_setnames->size);
break;
}
goto copy;
}
case IP_SET_OP_LIST: {
- struct ip_set_req_list *req_list
- = (struct ip_set_req_list *) data;
+ struct ip_set_req_list *req_list = data;
ip_set_id_t i;
int used;
goto copy;
}
case IP_SET_OP_SAVE: {
- struct ip_set_req_list *req_save
- = (struct ip_set_req_list *) data;
+ struct ip_set_req_list *req_save = data;
ip_set_id_t i;
int used;
goto copy;
}
case IP_SET_OP_RESTORE: {
- struct ip_set_req_setnames *req_restore
- = (struct ip_set_req_setnames *) data;
+ struct ip_set_req_setnames *req_restore = data;
int line;
if (*len < sizeof(struct ip_set_req_setnames)
*
* 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.
+ * published by the Free Software Foundation.
*/
/* Kernel module implementing an ip hash set */
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;
+ struct ip_set_iphash *map = set->data;
__u32 id;
u_int16_t i;
ip_set_ip_t *elem;
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;
+ const struct ip_set_req_iphash *req = data;
if (size != sizeof(struct ip_set_req_iphash)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-testip_kernel(struct ip_set *set,
+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
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
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;
+ const struct ip_set_req_iphash *req = data;
if (size != sizeof(struct ip_set_req_iphash)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
size);
return -EINVAL;
}
- return __addip((struct ip_set_iphash *) set->data, req->ip, hash_ip);
+ return __addip(set->data, req->ip, hash_ip);
}
static int
-addip_kernel(struct ip_set *set,
+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
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
static int retry(struct ip_set *set)
{
- struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
+ struct ip_set_iphash *map = set->data;
ip_set_ip_t hash_ip, *elem;
void *members;
u_int32_t i, hashsize = map->hashsize;
"hashsize grows from %u to %u",
set->name, map->hashsize, hashsize);
- tmp = kmalloc(sizeof(struct ip_set_iphash)
+ tmp = kmalloc(sizeof(struct ip_set_iphash)
+ map->probes * sizeof(uint32_t), GFP_ATOMIC);
if (!tmp) {
DP("out of memory for %d bytes",
memcpy(tmp->initval, map->initval, map->probes * sizeof(uint32_t));
write_lock_bh(&set->lock);
- map = (struct ip_set_iphash *) set->data; /* Play safe */
+ map = 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)
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;
+ struct ip_set_iphash *map = set->data;
ip_set_ip_t id, *elem;
if (!ip)
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;
+ const struct ip_set_req_iphash *req = data;
if (size != sizeof(struct ip_set_req_iphash)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-delip_kernel(struct ip_set *set,
+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
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
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;
+ const struct ip_set_req_iphash_create *req = data;
struct ip_set_iphash *map;
uint16_t i;
return -ENOEXEC;
}
- map = kmalloc(sizeof(struct ip_set_iphash)
+ map = kmalloc(sizeof(struct ip_set_iphash)
+ req->probes * sizeof(uint32_t), GFP_KERNEL);
if (!map) {
DP("out of memory for %d bytes",
static void destroy(struct ip_set *set)
{
- struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
+ struct ip_set_iphash *map = set->data;
harray_free(map->members);
kfree(map);
static void flush(struct ip_set *set)
{
- struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
+ struct ip_set_iphash *map = set->data;
harray_flush(map->members, map->hashsize, sizeof(ip_set_ip_t));
map->elements = 0;
}
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;
+ struct ip_set_iphash *map = set->data;
+ struct ip_set_req_iphash_create *header = data;
header->hashsize = map->hashsize;
header->probes = map->probes;
static int list_members_size(const struct ip_set *set)
{
- struct ip_set_iphash *map = (struct ip_set_iphash *) set->data;
+ const struct ip_set_iphash *map = 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;
+ const struct ip_set_iphash *map = set->data;
ip_set_ip_t i, *elem;
for (i = 0; i < map->hashsize; i++) {
*
* 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.
+ * published by the Free Software Foundation.
*/
/* Kernel module implementing an IP set type: the single bitmap type */
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;
+ struct ip_set_ipmap *map = set->data;
if (ip < map->first_ip || ip > map->last_ip)
return -ERANGE;
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;
+ const struct ip_set_req_ipmap *req = data;
if (size != sizeof(struct ip_set_req_ipmap)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-testip_kernel(struct ip_set *set,
+testip_kernel(struct ip_set *set,
const struct sk_buff *skb,
ip_set_ip_t *hash_ip,
const u_int32_t *flags,
int res = __testip(set,
ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
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;
+ struct ip_set_ipmap *map = set->data;
if (ip < map->first_ip || ip > map->last_ip)
return -ERANGE;
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;
+ const struct ip_set_req_ipmap *req = data;
if (size != sizeof(struct ip_set_req_ipmap)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-addip_kernel(struct ip_set *set,
+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
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
}
-static inline int
+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;
+ struct ip_set_ipmap *map = set->data;
if (ip < map->first_ip || ip > map->last_ip)
return -ERANGE;
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;
+ const struct ip_set_req_ipmap *req = data;
if (size != sizeof(struct ip_set_req_ipmap)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
unsigned char index)
{
return __delip(set,
- ntohl(flags[index] & IPSET_SRC
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
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;
+ const struct ip_set_req_ipmap_create *req = data;
struct ip_set_ipmap *map;
if (size != sizeof(struct ip_set_req_ipmap_create)) {
static void destroy(struct ip_set *set)
{
- struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
+ struct ip_set_ipmap *map = set->data;
kfree(map->members);
kfree(map);
static void flush(struct ip_set *set)
{
- struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
+ struct ip_set_ipmap *map = 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;
+ const struct ip_set_ipmap *map = set->data;
+ struct ip_set_req_ipmap_create *header = data;
header->from = map->first_ip;
header->to = map->last_ip;
static int list_members_size(const struct ip_set *set)
{
- struct ip_set_ipmap *map = (struct ip_set_ipmap *) set->data;
+ const struct ip_set_ipmap *map = 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;
+ const struct ip_set_ipmap *map = set->data;
int bytes = bitmap_bytes(0, map->sizeid - 1);
memcpy(data, map->members, bytes);
*
* 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.
+ * published by the Free Software Foundation.
*/
/* Kernel module implementing an ip+port hash set */
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;
+ struct ip_set_ipporthash *map = set->data;
__u32 id;
u_int16_t i;
ip_set_ip_t *elem;
__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;
+ struct ip_set_ipporthash *map = set->data;
if (ip < map->first_ip || ip > map->last_ip)
return -ERANGE;
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;
+ const struct ip_set_req_ipporthash *req = data;
if (size != sizeof(struct ip_set_req_ipporthash)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-testip_kernel(struct ip_set *set,
+testip_kernel(struct ip_set *set,
const struct sk_buff *skb,
ip_set_ip_t *hash_ip,
const u_int32_t *flags,
NIPQUAD(skb->nh.iph->daddr));
#endif
DP("flag %s port %u",
- flags[index+1] & IPSET_SRC ? "SRC" : "DST",
+ flags[index+1] & IPSET_SRC ? "SRC" : "DST",
port);
if (port == INVALID_PORT)
return 0;
res = __testip(set,
- ntohl(flags[index] & IPSET_SRC
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
port,
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;
+ const struct ip_set_req_ipporthash *req = data;
if (size != sizeof(struct ip_set_req_ipporthash)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
size);
return -EINVAL;
}
- return __addip((struct ip_set_ipporthash *) set->data,
- req->ip, req->port, hash_ip);
+ return __addip(set->data, req->ip, req->port, hash_ip);
}
static int
-addip_kernel(struct ip_set *set,
+addip_kernel(struct ip_set *set,
const struct sk_buff *skb,
ip_set_ip_t *hash_ip,
const u_int32_t *flags,
NIPQUAD(skb->nh.iph->saddr),
NIPQUAD(skb->nh.iph->daddr));
#endif
- DP("flag %s port %u",
- flags[index+1] & IPSET_SRC ? "SRC" : "DST",
+ 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
+ return __addip(set->data,
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
port,
static int retry(struct ip_set *set)
{
- struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
+ struct ip_set_ipporthash *map = set->data;
ip_set_ip_t *elem;
void *members;
u_int32_t i, hashsize = map->hashsize;
"hashsize grows from %u to %u",
set->name, map->hashsize, hashsize);
- tmp = kmalloc(sizeof(struct ip_set_ipporthash)
+ tmp = kmalloc(sizeof(struct ip_set_ipporthash)
+ map->probes * sizeof(uint32_t), GFP_ATOMIC);
if (!tmp) {
DP("out of memory for %d bytes",
memcpy(tmp->initval, map->initval, map->probes * sizeof(uint32_t));
write_lock_bh(&set->lock);
- map = (struct ip_set_ipporthash *) set->data; /* Play safe */
+ map = 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)
__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;
+ struct ip_set_ipporthash *map = set->data;
ip_set_ip_t id;
ip_set_ip_t *elem;
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;
+ const struct ip_set_req_ipporthash *req = data;
if (size != sizeof(struct ip_set_req_ipporthash)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-delip_kernel(struct ip_set *set,
+delip_kernel(struct ip_set *set,
const struct sk_buff *skb,
ip_set_ip_t *hash_ip,
const u_int32_t *flags,
NIPQUAD(skb->nh.iph->daddr));
#endif
DP("flag %s port %u",
- flags[index+1] & IPSET_SRC ? "SRC" : "DST",
+ flags[index+1] & IPSET_SRC ? "SRC" : "DST",
port);
if (port == INVALID_PORT)
return -EINVAL;
return __delip(set,
- ntohl(flags[index] & IPSET_SRC
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
port,
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;
+ const struct ip_set_req_ipporthash_create *req = data;
struct ip_set_ipporthash *map;
uint16_t i;
return -ENOEXEC;
}
- map = kmalloc(sizeof(struct ip_set_ipporthash)
+ map = kmalloc(sizeof(struct ip_set_ipporthash)
+ req->probes * sizeof(uint32_t), GFP_KERNEL);
if (!map) {
DP("out of memory for %d bytes",
static void destroy(struct ip_set *set)
{
- struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
+ struct ip_set_ipporthash *map = set->data;
harray_free(map->members);
kfree(map);
static void flush(struct ip_set *set)
{
- struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
+ struct ip_set_ipporthash *map = set->data;
harray_flush(map->members, map->hashsize, sizeof(ip_set_ip_t));
map->elements = 0;
}
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;
+ const struct ip_set_ipporthash *map = set->data;
+ struct ip_set_req_ipporthash_create *header = data;
header->hashsize = map->hashsize;
header->probes = map->probes;
static int list_members_size(const struct ip_set *set)
{
- struct ip_set_ipporthash *map = (struct ip_set_ipporthash *) set->data;
+ const struct ip_set_ipporthash *map = 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;
+ const struct ip_set_ipporthash *map = set->data;
ip_set_ip_t i, *elem;
for (i = 0; i < map->hashsize; i++) {
*
* 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.
+ * published by the Free Software Foundation.
*/
/* Kernel module implementing an IP set type: the iptree type */
/* 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 */
+/* Sleep so many milliseconds before trying again
+ * to delete the gc timer at destroying/flushing a set */
#define IPTREE_DESTROY_SLEEP 100
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
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_iptree *map = set->data;
struct ip_set_iptreeb *btree;
struct ip_set_iptreec *ctree;
struct ip_set_iptreed *dtree;
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;
+ const struct ip_set_req_iptree *req = data;
if (size != sizeof(struct ip_set_req_iptree)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-testip_kernel(struct ip_set *set,
+testip_kernel(struct ip_set *set,
const struct sk_buff *skb,
ip_set_ip_t *hash_ip,
const u_int32_t *flags,
#endif
res = __testip(set,
- ntohl(flags[index] & IPSET_SRC
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
__addip(struct ip_set *set, ip_set_ip_t ip, unsigned int timeout,
ip_set_ip_t *hash_ip)
{
- struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
+ struct ip_set_iptree *map = set->data;
struct ip_set_iptreeb *btree;
struct ip_set_iptreec *ctree;
struct ip_set_iptreed *dtree;
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;
+ struct ip_set_iptree *map = set->data;
+ const struct ip_set_req_iptree *req = data;
if (size != sizeof(struct ip_set_req_iptree)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-addip_kernel(struct ip_set *set,
+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;
+ struct ip_set_iptree *map = set->data;
return __addip(set,
- ntohl(flags[index] & IPSET_SRC
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
map->timeout,
return -EEXIST; \
} while (0)
-static inline int
+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_iptree *map = set->data;
struct ip_set_iptreeb *btree;
struct ip_set_iptreec *ctree;
struct ip_set_iptreed *dtree;
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;
+ const struct ip_set_req_iptree *req = data;
if (size != sizeof(struct ip_set_req_iptree)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-delip_kernel(struct ip_set *set,
+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
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
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 *set = (struct ip_set *) ul_set;
+ struct ip_set_iptree *map = set->data;
struct ip_set_iptreeb *btree;
struct ip_set_iptreec *ctree;
struct ip_set_iptreed *dtree;
static inline void init_gc_timer(struct ip_set *set)
{
- struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
+ struct ip_set_iptree *map = set->data;
/* Even if there is no timeout for the entries,
* we still have to call gc because delete
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;
+ const struct ip_set_req_iptree_create *req = data;
struct ip_set_iptree *map;
if (size != sizeof(struct ip_set_req_iptree_create)) {
static void destroy(struct ip_set *set)
{
- struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
+ struct ip_set_iptree *map = set->data;
/* gc might be running */
while (!del_timer(&map->gc))
static void flush(struct ip_set *set)
{
- struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
+ struct ip_set_iptree *map = set->data;
unsigned int timeout = map->timeout;
/* gc might be running */
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;
+ const struct ip_set_iptree *map = set->data;
+ struct ip_set_req_iptree_create *header = 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;
+ const struct ip_set_iptree *map = set->data;
struct ip_set_iptreeb *btree;
struct ip_set_iptreec *ctree;
struct ip_set_iptreed *dtree;
static void list_members(const struct ip_set *set, void *data)
{
- struct ip_set_iptree *map = (struct ip_set_iptree *) set->data;
+ const struct ip_set_iptree *map = set->data;
struct ip_set_iptreeb *btree;
struct ip_set_iptreec *ctree;
struct ip_set_iptreed *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 = data + offset;
entry->ip = ((a << 24) | (b << 16) | (c << 8) | d);
- entry->timeout = !map->timeout ? 0
+ entry->timeout = !map->timeout ? 0
: (dtree->expires[d] - jiffies)/HZ;
offset += sizeof(struct ip_set_req_iptree);
}
*/
/* This modules implements the iptreemap ipset type. It uses bitmaps to
- * represent every single IPv4 address as a single bit. The bitmaps are managed
- * in a tree structure, where the first three octets of an addresses are used
- * as an index to find the bitmap and the last octet is used as the bit number.
+ * represent every single IPv4 address as a bit. The bitmaps are managed in a
+ * tree structure, where the first three octets of an address are used as an
+ * index to find the bitmap and the last octet is used as the bit number.
*/
#include <linux/version.h>
+#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/ip.h>
#include <linux/skbuff.h>
#define LOOP_WALK_END_COUNT() \
}
-#define MIN(a, b) (a < b ? a : b)
-#define MAX(a, b) (a > b ? a : b)
-
#define GETVALUE1(a, a1, b1, r) \
(a == a1 ? b1 : r)
static inline int
__testip(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
struct ip_set_iptreemap_b *btree;
struct ip_set_iptreemap_c *ctree;
struct ip_set_iptreemap_d *dtree;
static int
testip(struct ip_set *set, const void *data, size_t size, ip_set_ip_t *hash_ip)
{
- struct ip_set_req_iptreemap *req = (struct ip_set_req_iptreemap *) data;
+ const struct ip_set_req_iptreemap *req = data;
if (size != sizeof(struct ip_set_req_iptreemap)) {
ip_set_printk("data length wrong (want %zu, have %zu)", sizeof(struct ip_set_req_iptreemap), size);
{
int res;
- res = __testip(set,
- ntohl(flags[index] & IPSET_SRC
+ res = __testip(set,
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
ADDIP_WALK(btree, b, ctree, struct ip_set_iptreemap_c, cachep_c, fullbitmap_c);
ADDIP_WALK(ctree, c, dtree, struct ip_set_iptreemap_d, cachep_d, fullbitmap_d);
- if (test_and_set_bit(d, (void *) dtree->bitmap))
+ if (__test_and_set_bit(d, (void *) dtree->bitmap))
return -EEXIST;
- set_bit(b, (void *) btree->dirty);
+ __set_bit(b, (void *) btree->dirty);
return 0;
}
static inline int
__addip_range(struct ip_set *set, ip_set_ip_t start, ip_set_ip_t end, ip_set_ip_t *hash_ip)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
struct ip_set_iptreemap_b *btree;
struct ip_set_iptreemap_c *ctree;
struct ip_set_iptreemap_d *dtree;
ADDIP_RANGE_LOOP(btree, b, GETVALUE1(a, a1, b1, 0), GETVALUE1(a, a2, b2, 255), CHECK2(a, b, a1, a2, b1, b2, c1, c2, d1, d2), ctree, fullbitmap_c, cachep_c, free_c) {
ADDIP_RANGE_LOOP(ctree, c, GETVALUE2(a, b, a1, b1, c1, 0), GETVALUE2(a, b, a2, b2, c2, 255), CHECK3(a, b, c, a1, a2, b1, b2, c1, c2, d1, d2), dtree, fullbitmap_d, cachep_d, free_d) {
for (d = GETVALUE3(a, b, c, a1, b1, c1, d1, 0); d <= GETVALUE3(a, b, c, a2, b2, c2, d2, 255); d++)
- set_bit(d, (void *) dtree->bitmap);
- set_bit(b, (void *) btree->dirty);
+ __set_bit(d, (void *) dtree->bitmap);
+ __set_bit(b, (void *) btree->dirty);
} ADDIP_RANGE_LOOP_END();
} ADDIP_RANGE_LOOP_END();
} ADDIP_RANGE_LOOP_END();
static int
addip(struct ip_set *set, const void *data, size_t size, ip_set_ip_t *hash_ip)
{
- struct ip_set_req_iptreemap *req = (struct ip_set_req_iptreemap *) data;
+ const struct ip_set_req_iptreemap *req = data;
if (size != sizeof(struct ip_set_req_iptreemap)) {
ip_set_printk("data length wrong (want %zu, have %zu)", sizeof(struct ip_set_req_iptreemap), size);
return -EINVAL;
}
- return __addip_range(set, MIN(req->start, req->end), MAX(req->start, req->end), hash_ip);
+ return __addip_range(set, min(req->start, req->end), max(req->start, req->end), hash_ip);
}
static int
{
return __addip_single(set,
- ntohl(flags[index] & IPSET_SRC
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
static inline int
__delip_single(struct ip_set *set, ip_set_ip_t ip, ip_set_ip_t *hash_ip, unsigned int __nocast flags)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
struct ip_set_iptreemap_b *btree;
struct ip_set_iptreemap_c *ctree;
struct ip_set_iptreemap_d *dtree;
DELIP_WALK(btree, b, ctree, cachep_c, fullbitmap_c, flags);
DELIP_WALK(ctree, c, dtree, cachep_d, fullbitmap_d, flags);
- if (!test_and_clear_bit(d, (void *) dtree->bitmap))
+ if (!__test_and_clear_bit(d, (void *) dtree->bitmap))
return -EEXIST;
- set_bit(b, (void *) btree->dirty);
+ __set_bit(b, (void *) btree->dirty);
return 0;
}
static inline int
__delip_range(struct ip_set *set, ip_set_ip_t start, ip_set_ip_t end, ip_set_ip_t *hash_ip, unsigned int __nocast flags)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
struct ip_set_iptreemap_b *btree;
struct ip_set_iptreemap_c *ctree;
struct ip_set_iptreemap_d *dtree;
DELIP_RANGE_LOOP(btree, b, GETVALUE1(a, a1, b1, 0), GETVALUE1(a, a2, b2, 255), CHECK2(a, b, a1, a2, b1, b2, c1, c2, d1, d2), ctree, fullbitmap_c, cachep_c, free_c, flags) {
DELIP_RANGE_LOOP(ctree, c, GETVALUE2(a, b, a1, b1, c1, 0), GETVALUE2(a, b, a2, b2, c2, 255), CHECK3(a, b, c, a1, a2, b1, b2, c1, c2, d1, d2), dtree, fullbitmap_d, cachep_d, free_d, flags) {
for (d = GETVALUE3(a, b, c, a1, b1, c1, d1, 0); d <= GETVALUE3(a, b, c, a2, b2, c2, d2, 255); d++)
- clear_bit(d, (void *) dtree->bitmap);
- set_bit(b, (void *) btree->dirty);
+ __clear_bit(d, (void *) dtree->bitmap);
+ __set_bit(b, (void *) btree->dirty);
} DELIP_RANGE_LOOP_END();
} DELIP_RANGE_LOOP_END();
} DELIP_RANGE_LOOP_END();
static int
delip(struct ip_set *set, const void *data, size_t size, ip_set_ip_t *hash_ip)
{
- struct ip_set_req_iptreemap *req = (struct ip_set_req_iptreemap *) data;
+ const struct ip_set_req_iptreemap *req = data;
if (size != sizeof(struct ip_set_req_iptreemap)) {
ip_set_printk("data length wrong (want %zu, have %zu)", sizeof(struct ip_set_req_iptreemap), size);
return -EINVAL;
}
- return __delip_range(set, MIN(req->start, req->end), MAX(req->start, req->end), hash_ip, GFP_KERNEL);
+ return __delip_range(set, min(req->start, req->end), max(req->start, req->end), hash_ip, GFP_KERNEL);
}
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_single(set,
- ntohl(flags[index] & IPSET_SRC
+ return __delip_single(set,
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip,
gc(unsigned long addr)
{
struct ip_set *set = (struct ip_set *) addr;
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
struct ip_set_iptreemap_b *btree;
struct ip_set_iptreemap_c *ctree;
struct ip_set_iptreemap_d *dtree;
LOOP_WALK_BEGIN_GC(map, a, btree, fullbitmap_b, cachep_b, i) {
LOOP_WALK_BEGIN_GC(btree, b, ctree, fullbitmap_c, cachep_c, j) {
- if (!test_and_clear_bit(b, (void *) btree->dirty))
+ if (!__test_and_clear_bit(b, (void *) btree->dirty))
continue;
LOOP_WALK_BEGIN_GC(ctree, c, dtree, fullbitmap_d, cachep_d, k) {
switch (bitmap_status(dtree)) {
static inline void
init_gc_timer(struct ip_set *set)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
init_timer(&map->gc);
map->gc.data = (unsigned long) set;
static int create(struct ip_set *set, const void *data, size_t size)
{
- struct ip_set_req_iptreemap_create *req = (struct ip_set_req_iptreemap_create *) data;
+ const struct ip_set_req_iptreemap_create *req = data;
struct ip_set_iptreemap *map;
if (size != sizeof(struct ip_set_req_iptreemap_create)) {
static void destroy(struct ip_set *set)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
while (!del_timer(&map->gc))
msleep(IPTREEMAP_DESTROY_SLEEP);
static void flush(struct ip_set *set)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
while (!del_timer(&map->gc))
msleep(IPTREEMAP_DESTROY_SLEEP);
static void list_header(const struct ip_set *set, void *data)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
- struct ip_set_req_iptreemap_create *header = (struct ip_set_req_iptreemap_create *) data;
+ struct ip_set_iptreemap *map = set->data;
+ struct ip_set_req_iptreemap_create *header = data;
header->gc_interval = map->gc_interval;
}
static int list_members_size(const struct ip_set *set)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
struct ip_set_iptreemap_b *btree;
struct ip_set_iptreemap_c *ctree;
struct ip_set_iptreemap_d *dtree;
static inline size_t add_member(void *data, size_t offset, ip_set_ip_t start, ip_set_ip_t end)
{
- struct ip_set_req_iptreemap *entry = (struct ip_set_req_iptreemap *) (data + offset);
+ struct ip_set_req_iptreemap *entry = data + offset;
entry->start = start;
entry->end = end;
static void list_members(const struct ip_set *set, void *data)
{
- struct ip_set_iptreemap *map = (struct ip_set_iptreemap *) set->data;
+ struct ip_set_iptreemap *map = set->data;
struct ip_set_iptreemap_b *btree;
struct ip_set_iptreemap_c *ctree;
struct ip_set_iptreemap_d *dtree;
int a;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
- cachep_b = kmem_cache_create("ip_set_iptreemap_b",
- sizeof(struct ip_set_iptreemap_b),
+ cachep_b = kmem_cache_create("ip_set_iptreemap_b",
+ sizeof(struct ip_set_iptreemap_b),
0, 0, NULL);
#else
- cachep_b = kmem_cache_create("ip_set_iptreemap_b",
- sizeof(struct ip_set_iptreemap_b),
+ cachep_b = kmem_cache_create("ip_set_iptreemap_b",
+ sizeof(struct ip_set_iptreemap_b),
0, 0, NULL, NULL);
#endif
if (!cachep_b) {
}
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
- cachep_c = kmem_cache_create("ip_set_iptreemap_c",
+ cachep_c = kmem_cache_create("ip_set_iptreemap_c",
sizeof(struct ip_set_iptreemap_c),
0, 0, NULL);
#else
- cachep_c = kmem_cache_create("ip_set_iptreemap_c",
+ cachep_c = kmem_cache_create("ip_set_iptreemap_c",
sizeof(struct ip_set_iptreemap_c),
0, 0, NULL, NULL);
#endif
*
* 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.
+ * published by the Free Software Foundation.
*/
/* Kernel module implementing an IP set type: the macipmap type */
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;
+ struct ip_set_macipmap *map = set->data;
+ struct ip_set_macip *table = map->members;
+ const struct ip_set_req_macipmap *req = data;
if (size != sizeof(struct ip_set_req_macipmap)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-testip_kernel(struct ip_set *set,
+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;
+ struct ip_set_macipmap *map = set->data;
+ struct ip_set_macip *table = map->members;
ip_set_ip_t ip;
ip = ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr);
#else
? skb->nh.iph->saddr
/* 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)
+__addip(struct ip_set *set,
+ ip_set_ip_t ip, const 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;
+ struct ip_set_macipmap *map = set->data;
+ struct ip_set_macip *table = map->members;
if (ip < map->first_ip || ip > map->last_ip)
return -ERANGE;
- if (test_and_set_bit(IPSET_MACIP_ISSET,
+ if (test_and_set_bit(IPSET_MACIP_ISSET,
(void *) &table[ip - map->first_ip].flags))
return -EEXIST;
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;
+ const struct ip_set_req_macipmap *req = data;
if (size != sizeof(struct ip_set_req_macipmap)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-addip_kernel(struct ip_set *set,
+addip_kernel(struct ip_set *set,
const struct sk_buff *skb,
ip_set_ip_t *hash_ip,
const u_int32_t *flags,
ip = ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr);
#else
? skb->nh.iph->saddr
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;
+ struct ip_set_macipmap *map = set->data;
+ struct ip_set_macip *table = map->members;
if (ip < map->first_ip || ip > map->last_ip)
return -ERANGE;
- if (!test_and_clear_bit(IPSET_MACIP_ISSET,
+ if (!test_and_clear_bit(IPSET_MACIP_ISSET,
(void *)&table[ip - map->first_ip].flags))
return -EEXIST;
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;
+ const struct ip_set_req_macipmap *req = data;
if (size != sizeof(struct ip_set_req_macipmap)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
unsigned char index)
{
return __delip(set,
- ntohl(flags[index] & IPSET_SRC
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
static int create(struct ip_set *set, const void *data, size_t size)
{
size_t newbytes;
- struct ip_set_req_macipmap_create *req =
- (struct ip_set_req_macipmap_create *) data;
+ const struct ip_set_req_macipmap_create *req = data;
struct ip_set_macipmap *map;
if (size != sizeof(struct ip_set_req_macipmap_create)) {
static void destroy(struct ip_set *set)
{
- struct ip_set_macipmap *map =
- (struct ip_set_macipmap *) set->data;
+ struct ip_set_macipmap *map = set->data;
ip_set_free(map->members, members_size(map->first_ip, map->last_ip));
kfree(map);
static void flush(struct ip_set *set)
{
- struct ip_set_macipmap *map =
- (struct ip_set_macipmap *) set->data;
+ struct ip_set_macipmap *map = 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;
+ const struct ip_set_macipmap *map = set->data;
+ struct ip_set_req_macipmap_create *header = data;
DP("list_header %x %x %u", map->first_ip, map->last_ip,
map->flags);
static int list_members_size(const struct ip_set *set)
{
- struct ip_set_macipmap *map =
- (struct ip_set_macipmap *) set->data;
+ const struct ip_set_macipmap *map = 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;
+ const struct ip_set_macipmap *map = set->data;
int bytes = members_size(map->first_ip, map->last_ip);
*
* 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.
+ * published by the Free Software Foundation.
*/
/* Kernel module implementing a cidr nethash set */
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;
+ struct ip_set_nethash *map = set->data;
__u32 id = UINT_MAX;
int i;
__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;
+ struct ip_set_nethash *map = set->data;
return (ip && hash_id_cidr(map, ip, cidr, hash_ip) != UINT_MAX);
}
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;
+ const struct ip_set_req_nethash *req = data;
if (size != sizeof(struct ip_set_req_nethash)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-testip_kernel(struct ip_set *set,
+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
+ ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr),
#else
- ? skb->nh.iph->saddr
+ ? skb->nh.iph->saddr
: skb->nh.iph->daddr),
#endif
hash_ip);
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;
+ const struct ip_set_req_nethash *req = data;
int ret;
if (size != sizeof(struct ip_set_req_nethash)) {
size);
return -EINVAL;
}
- ret = __addip((struct ip_set_nethash *) set->data,
- req->ip, req->cidr, hash_ip);
+ ret = __addip(set->data, req->ip, req->cidr, hash_ip);
if (ret == 0)
- update_cidr_sizes((struct ip_set_nethash *) set->data,
- req->cidr);
+ update_cidr_sizes(set->data, req->cidr);
return ret;
}
static int
-addip_kernel(struct ip_set *set,
+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;
+ struct ip_set_nethash *map = set->data;
int ret = -ERANGE;
- ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC
+ ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr);
#else
? skb->nh.iph->saddr
static int retry(struct ip_set *set)
{
- struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
+ struct ip_set_nethash *map = set->data;
ip_set_ip_t *elem;
void *members;
u_int32_t i, hashsize = map->hashsize;
"hashsize grows from %u to %u",
set->name, map->hashsize, hashsize);
- tmp = kmalloc(sizeof(struct ip_set_nethash)
+ tmp = kmalloc(sizeof(struct ip_set_nethash)
+ map->probes * sizeof(uint32_t), GFP_ATOMIC);
if (!tmp) {
DP("out of memory for %d bytes",
memcpy(tmp->cidr, map->cidr, 30 * sizeof(unsigned char));
write_lock_bh(&set->lock);
- map = (struct ip_set_nethash *) set->data; /* Play safe */
+ map = 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)
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;
+ const struct ip_set_req_nethash *req = data;
if (size != sizeof(struct ip_set_req_nethash)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
return -EINVAL;
}
/* TODO: no garbage collection in map->cidr */
- return __delip((struct ip_set_nethash *) set->data,
- req->ip, req->cidr, hash_ip);
+ return __delip(set->data, req->ip, req->cidr, hash_ip);
}
static int
-delip_kernel(struct ip_set *set,
+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;
+ struct ip_set_nethash *map = set->data;
int ret = -ERANGE;
- ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC
+ ip_set_ip_t ip = ntohl(flags[index] & IPSET_SRC
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
- ? ip_hdr(skb)->saddr
+ ? ip_hdr(skb)->saddr
: ip_hdr(skb)->daddr);
#else
? skb->nh.iph->saddr
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;
+ const struct ip_set_req_nethash_create *req = data;
struct ip_set_nethash *map;
uint16_t i;
static void destroy(struct ip_set *set)
{
- struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
+ struct ip_set_nethash *map = set->data;
harray_free(map->members);
kfree(map);
static void flush(struct ip_set *set)
{
- struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
+ struct ip_set_nethash *map = set->data;
harray_flush(map->members, map->hashsize, sizeof(ip_set_ip_t));
memset(map->cidr, 0, 30 * sizeof(unsigned char));
map->elements = 0;
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;
+ const struct ip_set_nethash *map = set->data;
+ struct ip_set_req_nethash_create *header = data;
header->hashsize = map->hashsize;
header->probes = map->probes;
static int list_members_size(const struct ip_set *set)
{
- struct ip_set_nethash *map = (struct ip_set_nethash *) set->data;
+ struct ip_set_nethash *map = 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;
+ const struct ip_set_nethash *map = set->data;
ip_set_ip_t i, *elem;
for (i = 0; i < map->hashsize; i++) {
*
* 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.
+ * published by the Free Software Foundation.
*/
/* Kernel module implementing a port set type as a bitmap */
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;
+ struct ip_set_portmap *map = set->data;
if (port < map->first_port || port > map->last_port)
return -ERANGE;
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;
+ const struct ip_set_req_portmap *req = data;
if (size != sizeof(struct ip_set_req_portmap)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-testport_kernel(struct ip_set *set,
+testport_kernel(struct ip_set *set,
const struct sk_buff *skb,
ip_set_ip_t *hash_port,
const u_int32_t *flags,
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;
+ struct ip_set_portmap *map = set->data;
if (port < map->first_port || port > map->last_port)
return -ERANGE;
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;
+ const struct ip_set_req_portmap *req = data;
if (size != sizeof(struct ip_set_req_portmap)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-addport_kernel(struct ip_set *set,
+addport_kernel(struct ip_set *set,
const struct sk_buff *skb,
ip_set_ip_t *hash_port,
const u_int32_t *flags,
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;
+ struct ip_set_portmap *map = set->data;
if (port < map->first_port || port > map->last_port)
return -ERANGE;
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;
+ const struct ip_set_req_portmap *req = data;
if (size != sizeof(struct ip_set_req_portmap)) {
ip_set_printk("data length wrong (want %zu, have %zu)",
}
static int
-delport_kernel(struct ip_set *set,
+delport_kernel(struct ip_set *set,
const struct sk_buff *skb,
ip_set_ip_t *hash_port,
const u_int32_t *flags,
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;
+ const struct ip_set_req_portmap_create *req = data;
struct ip_set_portmap *map;
if (size != sizeof(struct ip_set_req_portmap_create)) {
static void destroy(struct ip_set *set)
{
- struct ip_set_portmap *map = (struct ip_set_portmap *) set->data;
+ struct ip_set_portmap *map = set->data;
kfree(map->members);
kfree(map);
static void flush(struct ip_set *set)
{
- struct ip_set_portmap *map = (struct ip_set_portmap *) set->data;
+ struct ip_set_portmap *map = 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;
+ const struct ip_set_portmap *map = set->data;
+ struct ip_set_req_portmap_create *header = data;
DP("list_header %u %u", map->first_port, map->last_port);
static int list_members_size(const struct ip_set *set)
{
- struct ip_set_portmap *map = (struct ip_set_portmap *) set->data;
+ const struct ip_set_portmap *map = 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;
+ const struct ip_set_portmap *map = set->data;
int bytes = bitmap_bytes(map->first_port, map->last_port);
memcpy(data, map->members, bytes);
*
* 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.
+ * published by the Free Software Foundation.
*/
/* ipt_SET.c - netfilter target to manipulate IP sets */
#endif
void *targinfo,
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
- unsigned int targinfosize,
+ unsigned int targinfosize,
#endif
unsigned int hook_mask)
{
- struct ipt_set_info_target *info =
- (struct ipt_set_info_target *) targinfo;
+ struct ipt_set_info_target *info = targinfo;
ip_set_id_t index;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
*
* 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.
+ * published by the Free Software Foundation.
*/
/* Kernel module to match an IP set. */
#endif
unsigned int hook_mask)
{
- struct ipt_set_info_match *info =
- (struct ipt_set_info_match *) matchinfo;
+ struct ipt_set_info_match *info = matchinfo;
ip_set_id_t index;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
projects / thirdparty / xtables-addons.git / commitdiff
