1 /* Copyright (C) 2013 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 as
5 * published by the Free Software Foundation.
8 #ifndef __IP_SET_BITMAP_IP_GEN_H
9 #define __IP_SET_BITMAP_IP_GEN_H
11 #define mtype_do_test IPSET_TOKEN(MTYPE, _do_test)
12 #define mtype_gc_test IPSET_TOKEN(MTYPE, _gc_test)
13 #define mtype_is_filled IPSET_TOKEN(MTYPE, _is_filled)
14 #define mtype_do_add IPSET_TOKEN(MTYPE, _do_add)
15 #define mtype_ext_cleanup IPSET_TOKEN(MTYPE, _ext_cleanup)
16 #define mtype_do_del IPSET_TOKEN(MTYPE, _do_del)
17 #define mtype_do_list IPSET_TOKEN(MTYPE, _do_list)
18 #define mtype_do_head IPSET_TOKEN(MTYPE, _do_head)
19 #define mtype_adt_elem IPSET_TOKEN(MTYPE, _adt_elem)
20 #define mtype_add_timeout IPSET_TOKEN(MTYPE, _add_timeout)
21 #define mtype_gc_init IPSET_TOKEN(MTYPE, _gc_init)
22 #define mtype_kadt IPSET_TOKEN(MTYPE, _kadt)
23 #define mtype_uadt IPSET_TOKEN(MTYPE, _uadt)
24 #define mtype_destroy IPSET_TOKEN(MTYPE, _destroy)
25 #define mtype_flush IPSET_TOKEN(MTYPE, _flush)
26 #define mtype_head IPSET_TOKEN(MTYPE, _head)
27 #define mtype_same_set IPSET_TOKEN(MTYPE, _same_set)
28 #define mtype_elem IPSET_TOKEN(MTYPE, _elem)
29 #define mtype_test IPSET_TOKEN(MTYPE, _test)
30 #define mtype_add IPSET_TOKEN(MTYPE, _add)
31 #define mtype_del IPSET_TOKEN(MTYPE, _del)
32 #define mtype_list IPSET_TOKEN(MTYPE, _list)
33 #define mtype_gc IPSET_TOKEN(MTYPE, _gc)
36 #define get_ext(set, map, id) ((map)->extensions + (set)->dsize * (id))
39 mtype_gc_init(struct ip_set *set, void (*gc)(unsigned long ul_set))
41 struct mtype *map = set->data;
44 map->gc.data = (unsigned long) set;
45 map->gc.function = gc;
46 map->gc.expires = jiffies + IPSET_GC_PERIOD(set->timeout) * HZ;
51 mtype_ext_cleanup(struct ip_set *set)
53 struct mtype *map = set->data;
56 for (id = 0; id < map->elements; id++)
57 if (test_bit(id, map->members))
58 ip_set_ext_destroy(set, get_ext(set, map, id));
62 mtype_destroy(struct ip_set *set)
64 struct mtype *map = set->data;
66 if (SET_WITH_TIMEOUT(set))
67 del_timer_sync(&map->gc);
69 ip_set_free(map->members);
71 if (set->extensions & IPSET_EXT_DESTROY)
72 mtype_ext_cleanup(set);
73 ip_set_free(map->extensions);
81 mtype_flush(struct ip_set *set)
83 struct mtype *map = set->data;
85 if (set->extensions & IPSET_EXT_DESTROY)
86 mtype_ext_cleanup(set);
87 memset(map->members, 0, map->memsize);
91 mtype_head(struct ip_set *set, struct sk_buff *skb)
93 const struct mtype *map = set->data;
94 struct nlattr *nested;
96 nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
99 if (mtype_do_head(skb, map) ||
100 nla_put_net32(skb, IPSET_ATTR_REFERENCES, htonl(set->ref - 1)) ||
101 nla_put_net32(skb, IPSET_ATTR_MEMSIZE,
104 set->dsize * map->elements)))
105 goto nla_put_failure;
106 if (unlikely(ip_set_put_flags(skb, set)))
107 goto nla_put_failure;
108 ipset_nest_end(skb, nested);
116 mtype_test(struct ip_set *set, void *value, const struct ip_set_ext *ext,
117 struct ip_set_ext *mext, u32 flags)
119 struct mtype *map = set->data;
120 const struct mtype_adt_elem *e = value;
121 void *x = get_ext(set, map, e->id);
122 int ret = mtype_do_test(e, map, set->dsize);
126 if (SET_WITH_TIMEOUT(set) &&
127 ip_set_timeout_expired(ext_timeout(x, set)))
129 if (SET_WITH_COUNTER(set))
130 ip_set_update_counter(ext_counter(x, set), ext, mext, flags);
131 if (SET_WITH_SKBINFO(set))
132 ip_set_get_skbinfo(ext_skbinfo(x, set), ext, mext, flags);
137 mtype_add(struct ip_set *set, void *value, const struct ip_set_ext *ext,
138 struct ip_set_ext *mext, u32 flags)
140 struct mtype *map = set->data;
141 const struct mtype_adt_elem *e = value;
142 void *x = get_ext(set, map, e->id);
143 int ret = mtype_do_add(e, map, flags, set->dsize);
145 if (ret == IPSET_ADD_FAILED) {
146 if (SET_WITH_TIMEOUT(set) &&
147 ip_set_timeout_expired(ext_timeout(x, set)))
149 else if (!(flags & IPSET_FLAG_EXIST))
150 return -IPSET_ERR_EXIST;
151 /* Element is re-added, cleanup extensions */
152 ip_set_ext_destroy(set, x);
155 if (SET_WITH_TIMEOUT(set))
156 #ifdef IP_SET_BITMAP_STORED_TIMEOUT
157 mtype_add_timeout(ext_timeout(x, set), e, ext, set, map, ret);
159 ip_set_timeout_set(ext_timeout(x, set), ext->timeout);
162 if (SET_WITH_COUNTER(set))
163 ip_set_init_counter(ext_counter(x, set), ext);
164 if (SET_WITH_COMMENT(set))
165 ip_set_init_comment(ext_comment(x, set), ext);
166 if (SET_WITH_SKBINFO(set))
167 ip_set_init_skbinfo(ext_skbinfo(x, set), ext);
172 mtype_del(struct ip_set *set, void *value, const struct ip_set_ext *ext,
173 struct ip_set_ext *mext, u32 flags)
175 struct mtype *map = set->data;
176 const struct mtype_adt_elem *e = value;
177 void *x = get_ext(set, map, e->id);
179 if (mtype_do_del(e, map))
180 return -IPSET_ERR_EXIST;
182 ip_set_ext_destroy(set, x);
183 if (SET_WITH_TIMEOUT(set) &&
184 ip_set_timeout_expired(ext_timeout(x, set)))
185 return -IPSET_ERR_EXIST;
190 #ifndef IP_SET_BITMAP_STORED_TIMEOUT
192 mtype_is_filled(const struct mtype_elem *x)
199 mtype_list(const struct ip_set *set,
200 struct sk_buff *skb, struct netlink_callback *cb)
202 struct mtype *map = set->data;
203 struct nlattr *adt, *nested;
205 u32 id, first = cb->args[IPSET_CB_ARG0];
207 adt = ipset_nest_start(skb, IPSET_ATTR_ADT);
210 for (; cb->args[IPSET_CB_ARG0] < map->elements;
211 cb->args[IPSET_CB_ARG0]++) {
212 id = cb->args[IPSET_CB_ARG0];
213 x = get_ext(set, map, id);
214 if (!test_bit(id, map->members) ||
215 (SET_WITH_TIMEOUT(set) &&
216 #ifdef IP_SET_BITMAP_STORED_TIMEOUT
217 mtype_is_filled((const struct mtype_elem *) x) &&
219 ip_set_timeout_expired(ext_timeout(x, set))))
221 nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
224 nla_nest_cancel(skb, adt);
227 goto nla_put_failure;
229 if (mtype_do_list(skb, map, id, set->dsize))
230 goto nla_put_failure;
231 if (ip_set_put_extensions(skb, set, x,
232 mtype_is_filled((const struct mtype_elem *) x)))
233 goto nla_put_failure;
234 ipset_nest_end(skb, nested);
236 ipset_nest_end(skb, adt);
238 /* Set listing finished */
239 cb->args[IPSET_CB_ARG0] = 0;
244 nla_nest_cancel(skb, nested);
245 if (unlikely(id == first)) {
246 cb->args[IPSET_CB_ARG0] = 0;
249 ipset_nest_end(skb, adt);
254 mtype_gc(unsigned long ul_set)
256 struct ip_set *set = (struct ip_set *) ul_set;
257 struct mtype *map = set->data;
261 /* We run parallel with other readers (test element)
262 * but adding/deleting new entries is locked out */
263 read_lock_bh(&set->lock);
264 for (id = 0; id < map->elements; id++)
265 if (mtype_gc_test(id, map, set->dsize)) {
266 x = get_ext(set, map, id);
267 if (ip_set_timeout_expired(ext_timeout(x, set))) {
268 clear_bit(id, map->members);
269 ip_set_ext_destroy(set, x);
272 read_unlock_bh(&set->lock);
274 map->gc.expires = jiffies + IPSET_GC_PERIOD(set->timeout) * HZ;
278 static const struct ip_set_type_variant mtype = {
282 [IPSET_ADD] = mtype_add,
283 [IPSET_DEL] = mtype_del,
284 [IPSET_TEST] = mtype_test,
286 .destroy = mtype_destroy,
287 .flush = mtype_flush,
290 .same_set = mtype_same_set,
293 #endif /* __IP_SET_BITMAP_IP_GEN_H */