netfilter: ipset: references are protected by rwlock instead of mutex
[linux-2.6.git] / net / netfilter / ipset / ip_set_core.c
1 /* Copyright (C) 2000-2002 Joakim Axelsson <gozem@linux.nu>
2  *                         Patrick Schaaf <bof@bof.de>
3  * Copyright (C) 2003-2011 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  */
9
10 /* Kernel module for IP set management */
11
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/ip.h>
16 #include <linux/skbuff.h>
17 #include <linux/spinlock.h>
18 #include <linux/netlink.h>
19 #include <linux/rculist.h>
20 #include <linux/version.h>
21 #include <net/netlink.h>
22
23 #include <linux/netfilter.h>
24 #include <linux/netfilter/nfnetlink.h>
25 #include <linux/netfilter/ipset/ip_set.h>
26
27 static LIST_HEAD(ip_set_type_list);             /* all registered set types */
28 static DEFINE_MUTEX(ip_set_type_mutex);         /* protects ip_set_type_list */
29 static DEFINE_RWLOCK(ip_set_ref_lock);          /* protects the set refs */
30
31 static struct ip_set **ip_set_list;             /* all individual sets */
32 static ip_set_id_t ip_set_max = CONFIG_IP_SET_MAX; /* max number of sets */
33
34 #define STREQ(a, b)     (strncmp(a, b, IPSET_MAXNAMELEN) == 0)
35
36 static unsigned int max_sets;
37
38 module_param(max_sets, int, 0600);
39 MODULE_PARM_DESC(max_sets, "maximal number of sets");
40 MODULE_LICENSE("GPL");
41 MODULE_AUTHOR("Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>");
42 MODULE_DESCRIPTION("core IP set support");
43 MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_IPSET);
44
45 /*
46  * The set types are implemented in modules and registered set types
47  * can be found in ip_set_type_list. Adding/deleting types is
48  * serialized by ip_set_type_mutex.
49  */
50
51 static inline void
52 ip_set_type_lock(void)
53 {
54         mutex_lock(&ip_set_type_mutex);
55 }
56
57 static inline void
58 ip_set_type_unlock(void)
59 {
60         mutex_unlock(&ip_set_type_mutex);
61 }
62
63 /* Register and deregister settype */
64
65 static struct ip_set_type *
66 find_set_type(const char *name, u8 family, u8 revision)
67 {
68         struct ip_set_type *type;
69
70         list_for_each_entry_rcu(type, &ip_set_type_list, list)
71                 if (STREQ(type->name, name) &&
72                     (type->family == family || type->family == AF_UNSPEC) &&
73                     type->revision == revision)
74                         return type;
75         return NULL;
76 }
77
78 /* Unlock, try to load a set type module and lock again */
79 static int
80 try_to_load_type(const char *name)
81 {
82         nfnl_unlock();
83         pr_debug("try to load ip_set_%s\n", name);
84         if (request_module("ip_set_%s", name) < 0) {
85                 pr_warning("Can't find ip_set type %s\n", name);
86                 nfnl_lock();
87                 return -IPSET_ERR_FIND_TYPE;
88         }
89         nfnl_lock();
90         return -EAGAIN;
91 }
92
93 /* Find a set type and reference it */
94 static int
95 find_set_type_get(const char *name, u8 family, u8 revision,
96                   struct ip_set_type **found)
97 {
98         struct ip_set_type *type;
99         int err;
100
101         rcu_read_lock();
102         *found = find_set_type(name, family, revision);
103         if (*found) {
104                 err = !try_module_get((*found)->me) ? -EFAULT : 0;
105                 goto unlock;
106         }
107         /* Make sure the type is loaded but we don't support the revision */
108         list_for_each_entry_rcu(type, &ip_set_type_list, list)
109                 if (STREQ(type->name, name)) {
110                         err = -IPSET_ERR_FIND_TYPE;
111                         goto unlock;
112                 }
113         rcu_read_unlock();
114
115         return try_to_load_type(name);
116
117 unlock:
118         rcu_read_unlock();
119         return err;
120 }
121
122 /* Find a given set type by name and family.
123  * If we succeeded, the supported minimal and maximum revisions are
124  * filled out.
125  */
126 static int
127 find_set_type_minmax(const char *name, u8 family, u8 *min, u8 *max)
128 {
129         struct ip_set_type *type;
130         bool found = false;
131
132         *min = 255; *max = 0;
133         rcu_read_lock();
134         list_for_each_entry_rcu(type, &ip_set_type_list, list)
135                 if (STREQ(type->name, name) &&
136                     (type->family == family || type->family == AF_UNSPEC)) {
137                         found = true;
138                         if (type->revision < *min)
139                                 *min = type->revision;
140                         if (type->revision > *max)
141                                 *max = type->revision;
142                 }
143         rcu_read_unlock();
144         if (found)
145                 return 0;
146
147         return try_to_load_type(name);
148 }
149
150 #define family_name(f)  ((f) == AF_INET ? "inet" : \
151                          (f) == AF_INET6 ? "inet6" : "any")
152
153 /* Register a set type structure. The type is identified by
154  * the unique triple of name, family and revision.
155  */
156 int
157 ip_set_type_register(struct ip_set_type *type)
158 {
159         int ret = 0;
160
161         if (type->protocol != IPSET_PROTOCOL) {
162                 pr_warning("ip_set type %s, family %s, revision %u uses "
163                            "wrong protocol version %u (want %u)\n",
164                            type->name, family_name(type->family),
165                            type->revision, type->protocol, IPSET_PROTOCOL);
166                 return -EINVAL;
167         }
168
169         ip_set_type_lock();
170         if (find_set_type(type->name, type->family, type->revision)) {
171                 /* Duplicate! */
172                 pr_warning("ip_set type %s, family %s, revision %u "
173                            "already registered!\n", type->name,
174                            family_name(type->family), type->revision);
175                 ret = -EINVAL;
176                 goto unlock;
177         }
178         list_add_rcu(&type->list, &ip_set_type_list);
179         pr_debug("type %s, family %s, revision %u registered.\n",
180                  type->name, family_name(type->family), type->revision);
181 unlock:
182         ip_set_type_unlock();
183         return ret;
184 }
185 EXPORT_SYMBOL_GPL(ip_set_type_register);
186
187 /* Unregister a set type. There's a small race with ip_set_create */
188 void
189 ip_set_type_unregister(struct ip_set_type *type)
190 {
191         ip_set_type_lock();
192         if (!find_set_type(type->name, type->family, type->revision)) {
193                 pr_warning("ip_set type %s, family %s, revision %u "
194                            "not registered\n", type->name,
195                            family_name(type->family), type->revision);
196                 goto unlock;
197         }
198         list_del_rcu(&type->list);
199         pr_debug("type %s, family %s, revision %u unregistered.\n",
200                  type->name, family_name(type->family), type->revision);
201 unlock:
202         ip_set_type_unlock();
203
204         synchronize_rcu();
205 }
206 EXPORT_SYMBOL_GPL(ip_set_type_unregister);
207
208 /* Utility functions */
209 void *
210 ip_set_alloc(size_t size)
211 {
212         void *members = NULL;
213
214         if (size < KMALLOC_MAX_SIZE)
215                 members = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
216
217         if (members) {
218                 pr_debug("%p: allocated with kmalloc\n", members);
219                 return members;
220         }
221
222         members = vzalloc(size);
223         if (!members)
224                 return NULL;
225         pr_debug("%p: allocated with vmalloc\n", members);
226
227         return members;
228 }
229 EXPORT_SYMBOL_GPL(ip_set_alloc);
230
231 void
232 ip_set_free(void *members)
233 {
234         pr_debug("%p: free with %s\n", members,
235                  is_vmalloc_addr(members) ? "vfree" : "kfree");
236         if (is_vmalloc_addr(members))
237                 vfree(members);
238         else
239                 kfree(members);
240 }
241 EXPORT_SYMBOL_GPL(ip_set_free);
242
243 static inline bool
244 flag_nested(const struct nlattr *nla)
245 {
246         return nla->nla_type & NLA_F_NESTED;
247 }
248
249 static const struct nla_policy ipaddr_policy[IPSET_ATTR_IPADDR_MAX + 1] = {
250         [IPSET_ATTR_IPADDR_IPV4]        = { .type = NLA_U32 },
251         [IPSET_ATTR_IPADDR_IPV6]        = { .type = NLA_BINARY,
252                                             .len = sizeof(struct in6_addr) },
253 };
254
255 int
256 ip_set_get_ipaddr4(struct nlattr *nla,  __be32 *ipaddr)
257 {
258         struct nlattr *tb[IPSET_ATTR_IPADDR_MAX+1];
259
260         if (unlikely(!flag_nested(nla)))
261                 return -IPSET_ERR_PROTOCOL;
262         if (nla_parse_nested(tb, IPSET_ATTR_IPADDR_MAX, nla, ipaddr_policy))
263                 return -IPSET_ERR_PROTOCOL;
264         if (unlikely(!ip_set_attr_netorder(tb, IPSET_ATTR_IPADDR_IPV4)))
265                 return -IPSET_ERR_PROTOCOL;
266
267         *ipaddr = nla_get_be32(tb[IPSET_ATTR_IPADDR_IPV4]);
268         return 0;
269 }
270 EXPORT_SYMBOL_GPL(ip_set_get_ipaddr4);
271
272 int
273 ip_set_get_ipaddr6(struct nlattr *nla, union nf_inet_addr *ipaddr)
274 {
275         struct nlattr *tb[IPSET_ATTR_IPADDR_MAX+1];
276
277         if (unlikely(!flag_nested(nla)))
278                 return -IPSET_ERR_PROTOCOL;
279
280         if (nla_parse_nested(tb, IPSET_ATTR_IPADDR_MAX, nla, ipaddr_policy))
281                 return -IPSET_ERR_PROTOCOL;
282         if (unlikely(!ip_set_attr_netorder(tb, IPSET_ATTR_IPADDR_IPV6)))
283                 return -IPSET_ERR_PROTOCOL;
284
285         memcpy(ipaddr, nla_data(tb[IPSET_ATTR_IPADDR_IPV6]),
286                 sizeof(struct in6_addr));
287         return 0;
288 }
289 EXPORT_SYMBOL_GPL(ip_set_get_ipaddr6);
290
291 /*
292  * Creating/destroying/renaming/swapping affect the existence and
293  * the properties of a set. All of these can be executed from userspace
294  * only and serialized by the nfnl mutex indirectly from nfnetlink.
295  *
296  * Sets are identified by their index in ip_set_list and the index
297  * is used by the external references (set/SET netfilter modules).
298  *
299  * The set behind an index may change by swapping only, from userspace.
300  */
301
302 static inline void
303 __ip_set_get(ip_set_id_t index)
304 {
305         write_lock_bh(&ip_set_ref_lock);
306         ip_set_list[index]->ref++;
307         write_unlock_bh(&ip_set_ref_lock);
308 }
309
310 static inline void
311 __ip_set_put(ip_set_id_t index)
312 {
313         write_lock_bh(&ip_set_ref_lock);
314         BUG_ON(ip_set_list[index]->ref == 0);
315         ip_set_list[index]->ref--;
316         write_unlock_bh(&ip_set_ref_lock);
317 }
318
319 /*
320  * Add, del and test set entries from kernel.
321  *
322  * The set behind the index must exist and must be referenced
323  * so it can't be destroyed (or changed) under our foot.
324  */
325
326 int
327 ip_set_test(ip_set_id_t index, const struct sk_buff *skb,
328             u8 family, u8 dim, u8 flags)
329 {
330         struct ip_set *set = ip_set_list[index];
331         int ret = 0;
332
333         BUG_ON(set == NULL);
334         pr_debug("set %s, index %u\n", set->name, index);
335
336         if (dim < set->type->dimension ||
337             !(family == set->family || set->family == AF_UNSPEC))
338                 return 0;
339
340         read_lock_bh(&set->lock);
341         ret = set->variant->kadt(set, skb, IPSET_TEST, family, dim, flags);
342         read_unlock_bh(&set->lock);
343
344         if (ret == -EAGAIN) {
345                 /* Type requests element to be completed */
346                 pr_debug("element must be competed, ADD is triggered\n");
347                 write_lock_bh(&set->lock);
348                 set->variant->kadt(set, skb, IPSET_ADD, family, dim, flags);
349                 write_unlock_bh(&set->lock);
350                 ret = 1;
351         }
352
353         /* Convert error codes to nomatch */
354         return (ret < 0 ? 0 : ret);
355 }
356 EXPORT_SYMBOL_GPL(ip_set_test);
357
358 int
359 ip_set_add(ip_set_id_t index, const struct sk_buff *skb,
360            u8 family, u8 dim, u8 flags)
361 {
362         struct ip_set *set = ip_set_list[index];
363         int ret;
364
365         BUG_ON(set == NULL);
366         pr_debug("set %s, index %u\n", set->name, index);
367
368         if (dim < set->type->dimension ||
369             !(family == set->family || set->family == AF_UNSPEC))
370                 return 0;
371
372         write_lock_bh(&set->lock);
373         ret = set->variant->kadt(set, skb, IPSET_ADD, family, dim, flags);
374         write_unlock_bh(&set->lock);
375
376         return ret;
377 }
378 EXPORT_SYMBOL_GPL(ip_set_add);
379
380 int
381 ip_set_del(ip_set_id_t index, const struct sk_buff *skb,
382            u8 family, u8 dim, u8 flags)
383 {
384         struct ip_set *set = ip_set_list[index];
385         int ret = 0;
386
387         BUG_ON(set == NULL);
388         pr_debug("set %s, index %u\n", set->name, index);
389
390         if (dim < set->type->dimension ||
391             !(family == set->family || set->family == AF_UNSPEC))
392                 return 0;
393
394         write_lock_bh(&set->lock);
395         ret = set->variant->kadt(set, skb, IPSET_DEL, family, dim, flags);
396         write_unlock_bh(&set->lock);
397
398         return ret;
399 }
400 EXPORT_SYMBOL_GPL(ip_set_del);
401
402 /*
403  * Find set by name, reference it once. The reference makes sure the
404  * thing pointed to, does not go away under our feet.
405  *
406  */
407 ip_set_id_t
408 ip_set_get_byname(const char *name, struct ip_set **set)
409 {
410         ip_set_id_t i, index = IPSET_INVALID_ID;
411         struct ip_set *s;
412
413         for (i = 0; i < ip_set_max; i++) {
414                 s = ip_set_list[i];
415                 if (s != NULL && STREQ(s->name, name)) {
416                         __ip_set_get(i);
417                         index = i;
418                         *set = s;
419                 }
420         }
421
422         return index;
423 }
424 EXPORT_SYMBOL_GPL(ip_set_get_byname);
425
426 /*
427  * If the given set pointer points to a valid set, decrement
428  * reference count by 1. The caller shall not assume the index
429  * to be valid, after calling this function.
430  *
431  */
432 void
433 ip_set_put_byindex(ip_set_id_t index)
434 {
435         if (ip_set_list[index] != NULL)
436                 __ip_set_put(index);
437 }
438 EXPORT_SYMBOL_GPL(ip_set_put_byindex);
439
440 /*
441  * Get the name of a set behind a set index.
442  * We assume the set is referenced, so it does exist and
443  * can't be destroyed. The set cannot be renamed due to
444  * the referencing either.
445  *
446  */
447 const char *
448 ip_set_name_byindex(ip_set_id_t index)
449 {
450         const struct ip_set *set = ip_set_list[index];
451
452         BUG_ON(set == NULL);
453         BUG_ON(set->ref == 0);
454
455         /* Referenced, so it's safe */
456         return set->name;
457 }
458 EXPORT_SYMBOL_GPL(ip_set_name_byindex);
459
460 /*
461  * Routines to call by external subsystems, which do not
462  * call nfnl_lock for us.
463  */
464
465 /*
466  * Find set by name, reference it once. The reference makes sure the
467  * thing pointed to, does not go away under our feet.
468  *
469  * The nfnl mutex is used in the function.
470  */
471 ip_set_id_t
472 ip_set_nfnl_get(const char *name)
473 {
474         struct ip_set *s;
475         ip_set_id_t index;
476
477         nfnl_lock();
478         index = ip_set_get_byname(name, &s);
479         nfnl_unlock();
480
481         return index;
482 }
483 EXPORT_SYMBOL_GPL(ip_set_nfnl_get);
484
485 /*
486  * Find set by index, reference it once. The reference makes sure the
487  * thing pointed to, does not go away under our feet.
488  *
489  * The nfnl mutex is used in the function.
490  */
491 ip_set_id_t
492 ip_set_nfnl_get_byindex(ip_set_id_t index)
493 {
494         if (index > ip_set_max)
495                 return IPSET_INVALID_ID;
496
497         nfnl_lock();
498         if (ip_set_list[index])
499                 __ip_set_get(index);
500         else
501                 index = IPSET_INVALID_ID;
502         nfnl_unlock();
503
504         return index;
505 }
506 EXPORT_SYMBOL_GPL(ip_set_nfnl_get_byindex);
507
508 /*
509  * If the given set pointer points to a valid set, decrement
510  * reference count by 1. The caller shall not assume the index
511  * to be valid, after calling this function.
512  *
513  * The nfnl mutex is used in the function.
514  */
515 void
516 ip_set_nfnl_put(ip_set_id_t index)
517 {
518         nfnl_lock();
519         ip_set_put_byindex(index);
520         nfnl_unlock();
521 }
522 EXPORT_SYMBOL_GPL(ip_set_nfnl_put);
523
524 /*
525  * Communication protocol with userspace over netlink.
526  *
527  * The commands are serialized by the nfnl mutex.
528  */
529
530 static inline bool
531 protocol_failed(const struct nlattr * const tb[])
532 {
533         return !tb[IPSET_ATTR_PROTOCOL] ||
534                nla_get_u8(tb[IPSET_ATTR_PROTOCOL]) != IPSET_PROTOCOL;
535 }
536
537 static inline u32
538 flag_exist(const struct nlmsghdr *nlh)
539 {
540         return nlh->nlmsg_flags & NLM_F_EXCL ? 0 : IPSET_FLAG_EXIST;
541 }
542
543 static struct nlmsghdr *
544 start_msg(struct sk_buff *skb, u32 pid, u32 seq, unsigned int flags,
545           enum ipset_cmd cmd)
546 {
547         struct nlmsghdr *nlh;
548         struct nfgenmsg *nfmsg;
549
550         nlh = nlmsg_put(skb, pid, seq, cmd | (NFNL_SUBSYS_IPSET << 8),
551                         sizeof(*nfmsg), flags);
552         if (nlh == NULL)
553                 return NULL;
554
555         nfmsg = nlmsg_data(nlh);
556         nfmsg->nfgen_family = AF_INET;
557         nfmsg->version = NFNETLINK_V0;
558         nfmsg->res_id = 0;
559
560         return nlh;
561 }
562
563 /* Create a set */
564
565 static const struct nla_policy ip_set_create_policy[IPSET_ATTR_CMD_MAX + 1] = {
566         [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
567         [IPSET_ATTR_SETNAME]    = { .type = NLA_NUL_STRING,
568                                     .len = IPSET_MAXNAMELEN - 1 },
569         [IPSET_ATTR_TYPENAME]   = { .type = NLA_NUL_STRING,
570                                     .len = IPSET_MAXNAMELEN - 1},
571         [IPSET_ATTR_REVISION]   = { .type = NLA_U8 },
572         [IPSET_ATTR_FAMILY]     = { .type = NLA_U8 },
573         [IPSET_ATTR_DATA]       = { .type = NLA_NESTED },
574 };
575
576 static ip_set_id_t
577 find_set_id(const char *name)
578 {
579         ip_set_id_t i, index = IPSET_INVALID_ID;
580         const struct ip_set *set;
581
582         for (i = 0; index == IPSET_INVALID_ID && i < ip_set_max; i++) {
583                 set = ip_set_list[i];
584                 if (set != NULL && STREQ(set->name, name))
585                         index = i;
586         }
587         return index;
588 }
589
590 static inline struct ip_set *
591 find_set(const char *name)
592 {
593         ip_set_id_t index = find_set_id(name);
594
595         return index == IPSET_INVALID_ID ? NULL : ip_set_list[index];
596 }
597
598 static int
599 find_free_id(const char *name, ip_set_id_t *index, struct ip_set **set)
600 {
601         ip_set_id_t i;
602
603         *index = IPSET_INVALID_ID;
604         for (i = 0;  i < ip_set_max; i++) {
605                 if (ip_set_list[i] == NULL) {
606                         if (*index == IPSET_INVALID_ID)
607                                 *index = i;
608                 } else if (STREQ(name, ip_set_list[i]->name)) {
609                         /* Name clash */
610                         *set = ip_set_list[i];
611                         return -EEXIST;
612                 }
613         }
614         if (*index == IPSET_INVALID_ID)
615                 /* No free slot remained */
616                 return -IPSET_ERR_MAX_SETS;
617         return 0;
618 }
619
620 static int
621 ip_set_create(struct sock *ctnl, struct sk_buff *skb,
622               const struct nlmsghdr *nlh,
623               const struct nlattr * const attr[])
624 {
625         struct ip_set *set, *clash = NULL;
626         ip_set_id_t index = IPSET_INVALID_ID;
627         struct nlattr *tb[IPSET_ATTR_CREATE_MAX+1] = {};
628         const char *name, *typename;
629         u8 family, revision;
630         u32 flags = flag_exist(nlh);
631         int ret = 0;
632
633         if (unlikely(protocol_failed(attr) ||
634                      attr[IPSET_ATTR_SETNAME] == NULL ||
635                      attr[IPSET_ATTR_TYPENAME] == NULL ||
636                      attr[IPSET_ATTR_REVISION] == NULL ||
637                      attr[IPSET_ATTR_FAMILY] == NULL ||
638                      (attr[IPSET_ATTR_DATA] != NULL &&
639                       !flag_nested(attr[IPSET_ATTR_DATA]))))
640                 return -IPSET_ERR_PROTOCOL;
641
642         name = nla_data(attr[IPSET_ATTR_SETNAME]);
643         typename = nla_data(attr[IPSET_ATTR_TYPENAME]);
644         family = nla_get_u8(attr[IPSET_ATTR_FAMILY]);
645         revision = nla_get_u8(attr[IPSET_ATTR_REVISION]);
646         pr_debug("setname: %s, typename: %s, family: %s, revision: %u\n",
647                  name, typename, family_name(family), revision);
648
649         /*
650          * First, and without any locks, allocate and initialize
651          * a normal base set structure.
652          */
653         set = kzalloc(sizeof(struct ip_set), GFP_KERNEL);
654         if (!set)
655                 return -ENOMEM;
656         rwlock_init(&set->lock);
657         strlcpy(set->name, name, IPSET_MAXNAMELEN);
658         set->family = family;
659
660         /*
661          * Next, check that we know the type, and take
662          * a reference on the type, to make sure it stays available
663          * while constructing our new set.
664          *
665          * After referencing the type, we try to create the type
666          * specific part of the set without holding any locks.
667          */
668         ret = find_set_type_get(typename, family, revision, &(set->type));
669         if (ret)
670                 goto out;
671
672         /*
673          * Without holding any locks, create private part.
674          */
675         if (attr[IPSET_ATTR_DATA] &&
676             nla_parse_nested(tb, IPSET_ATTR_CREATE_MAX, attr[IPSET_ATTR_DATA],
677                              set->type->create_policy)) {
678                 ret = -IPSET_ERR_PROTOCOL;
679                 goto put_out;
680         }
681
682         ret = set->type->create(set, tb, flags);
683         if (ret != 0)
684                 goto put_out;
685
686         /* BTW, ret==0 here. */
687
688         /*
689          * Here, we have a valid, constructed set and we are protected
690          * by the nfnl mutex. Find the first free index in ip_set_list
691          * and check clashing.
692          */
693         if ((ret = find_free_id(set->name, &index, &clash)) != 0) {
694                 /* If this is the same set and requested, ignore error */
695                 if (ret == -EEXIST &&
696                     (flags & IPSET_FLAG_EXIST) &&
697                     STREQ(set->type->name, clash->type->name) &&
698                     set->type->family == clash->type->family &&
699                     set->type->revision == clash->type->revision &&
700                     set->variant->same_set(set, clash))
701                         ret = 0;
702                 goto cleanup;
703         }
704
705         /*
706          * Finally! Add our shiny new set to the list, and be done.
707          */
708         pr_debug("create: '%s' created with index %u!\n", set->name, index);
709         ip_set_list[index] = set;
710
711         return ret;
712
713 cleanup:
714         set->variant->destroy(set);
715 put_out:
716         module_put(set->type->me);
717 out:
718         kfree(set);
719         return ret;
720 }
721
722 /* Destroy sets */
723
724 static const struct nla_policy
725 ip_set_setname_policy[IPSET_ATTR_CMD_MAX + 1] = {
726         [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
727         [IPSET_ATTR_SETNAME]    = { .type = NLA_NUL_STRING,
728                                     .len = IPSET_MAXNAMELEN - 1 },
729 };
730
731 static void
732 ip_set_destroy_set(ip_set_id_t index)
733 {
734         struct ip_set *set = ip_set_list[index];
735
736         pr_debug("set: %s\n",  set->name);
737         ip_set_list[index] = NULL;
738
739         /* Must call it without holding any lock */
740         set->variant->destroy(set);
741         module_put(set->type->me);
742         kfree(set);
743 }
744
745 static int
746 ip_set_destroy(struct sock *ctnl, struct sk_buff *skb,
747                const struct nlmsghdr *nlh,
748                const struct nlattr * const attr[])
749 {
750         ip_set_id_t i;
751         int ret = 0;
752
753         if (unlikely(protocol_failed(attr)))
754                 return -IPSET_ERR_PROTOCOL;
755
756         /* Commands are serialized and references are
757          * protected by the ip_set_ref_lock.
758          * External systems (i.e. xt_set) must call
759          * ip_set_put|get_nfnl_* functions, that way we
760          * can safely check references here.
761          *
762          * list:set timer can only decrement the reference
763          * counter, so if it's already zero, we can proceed
764          * without holding the lock.
765          */
766         read_lock_bh(&ip_set_ref_lock);
767         if (!attr[IPSET_ATTR_SETNAME]) {
768                 for (i = 0; i < ip_set_max; i++) {
769                         if (ip_set_list[i] != NULL && ip_set_list[i]->ref) {
770                                 ret = IPSET_ERR_BUSY;
771                                 goto out;
772                         }
773                 }
774                 read_unlock_bh(&ip_set_ref_lock);
775                 for (i = 0; i < ip_set_max; i++) {
776                         if (ip_set_list[i] != NULL)
777                                 ip_set_destroy_set(i);
778                 }
779         } else {
780                 i = find_set_id(nla_data(attr[IPSET_ATTR_SETNAME]));
781                 if (i == IPSET_INVALID_ID) {
782                         ret = -ENOENT;
783                         goto out;
784                 } else if (ip_set_list[i]->ref) {
785                         ret = -IPSET_ERR_BUSY;
786                         goto out;
787                 }
788                 read_unlock_bh(&ip_set_ref_lock);
789
790                 ip_set_destroy_set(i);
791         }
792         return 0;
793 out:
794         read_unlock_bh(&ip_set_ref_lock);
795         return ret;
796 }
797
798 /* Flush sets */
799
800 static void
801 ip_set_flush_set(struct ip_set *set)
802 {
803         pr_debug("set: %s\n",  set->name);
804
805         write_lock_bh(&set->lock);
806         set->variant->flush(set);
807         write_unlock_bh(&set->lock);
808 }
809
810 static int
811 ip_set_flush(struct sock *ctnl, struct sk_buff *skb,
812              const struct nlmsghdr *nlh,
813              const struct nlattr * const attr[])
814 {
815         ip_set_id_t i;
816
817         if (unlikely(protocol_failed(attr)))
818                 return -EPROTO;
819
820         if (!attr[IPSET_ATTR_SETNAME]) {
821                 for (i = 0; i < ip_set_max; i++)
822                         if (ip_set_list[i] != NULL)
823                                 ip_set_flush_set(ip_set_list[i]);
824         } else {
825                 i = find_set_id(nla_data(attr[IPSET_ATTR_SETNAME]));
826                 if (i == IPSET_INVALID_ID)
827                         return -ENOENT;
828
829                 ip_set_flush_set(ip_set_list[i]);
830         }
831
832         return 0;
833 }
834
835 /* Rename a set */
836
837 static const struct nla_policy
838 ip_set_setname2_policy[IPSET_ATTR_CMD_MAX + 1] = {
839         [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
840         [IPSET_ATTR_SETNAME]    = { .type = NLA_NUL_STRING,
841                                     .len = IPSET_MAXNAMELEN - 1 },
842         [IPSET_ATTR_SETNAME2]   = { .type = NLA_NUL_STRING,
843                                     .len = IPSET_MAXNAMELEN - 1 },
844 };
845
846 static int
847 ip_set_rename(struct sock *ctnl, struct sk_buff *skb,
848               const struct nlmsghdr *nlh,
849               const struct nlattr * const attr[])
850 {
851         struct ip_set *set;
852         const char *name2;
853         ip_set_id_t i;
854         int ret = 0;
855
856         if (unlikely(protocol_failed(attr) ||
857                      attr[IPSET_ATTR_SETNAME] == NULL ||
858                      attr[IPSET_ATTR_SETNAME2] == NULL))
859                 return -IPSET_ERR_PROTOCOL;
860
861         set = find_set(nla_data(attr[IPSET_ATTR_SETNAME]));
862         if (set == NULL)
863                 return -ENOENT;
864
865         read_lock_bh(&ip_set_ref_lock);
866         if (set->ref != 0) {
867                 ret = -IPSET_ERR_REFERENCED;
868                 goto out;
869         }
870
871         name2 = nla_data(attr[IPSET_ATTR_SETNAME2]);
872         for (i = 0; i < ip_set_max; i++) {
873                 if (ip_set_list[i] != NULL &&
874                     STREQ(ip_set_list[i]->name, name2)) {
875                         ret = -IPSET_ERR_EXIST_SETNAME2;
876                         goto out;
877                 }
878         }
879         strncpy(set->name, name2, IPSET_MAXNAMELEN);
880
881 out:
882         read_unlock_bh(&ip_set_ref_lock);
883         return ret;
884 }
885
886 /* Swap two sets so that name/index points to the other.
887  * References and set names are also swapped.
888  *
889  * The commands are serialized by the nfnl mutex and references are
890  * protected by the ip_set_ref_lock. The kernel interfaces
891  * do not hold the mutex but the pointer settings are atomic
892  * so the ip_set_list always contains valid pointers to the sets.
893  */
894
895 static int
896 ip_set_swap(struct sock *ctnl, struct sk_buff *skb,
897             const struct nlmsghdr *nlh,
898             const struct nlattr * const attr[])
899 {
900         struct ip_set *from, *to;
901         ip_set_id_t from_id, to_id;
902         char from_name[IPSET_MAXNAMELEN];
903
904         if (unlikely(protocol_failed(attr) ||
905                      attr[IPSET_ATTR_SETNAME] == NULL ||
906                      attr[IPSET_ATTR_SETNAME2] == NULL))
907                 return -IPSET_ERR_PROTOCOL;
908
909         from_id = find_set_id(nla_data(attr[IPSET_ATTR_SETNAME]));
910         if (from_id == IPSET_INVALID_ID)
911                 return -ENOENT;
912
913         to_id = find_set_id(nla_data(attr[IPSET_ATTR_SETNAME2]));
914         if (to_id == IPSET_INVALID_ID)
915                 return -IPSET_ERR_EXIST_SETNAME2;
916
917         from = ip_set_list[from_id];
918         to = ip_set_list[to_id];
919
920         /* Features must not change.
921          * Not an artifical restriction anymore, as we must prevent
922          * possible loops created by swapping in setlist type of sets. */
923         if (!(from->type->features == to->type->features &&
924               from->type->family == to->type->family))
925                 return -IPSET_ERR_TYPE_MISMATCH;
926
927         strncpy(from_name, from->name, IPSET_MAXNAMELEN);
928         strncpy(from->name, to->name, IPSET_MAXNAMELEN);
929         strncpy(to->name, from_name, IPSET_MAXNAMELEN);
930
931         write_lock_bh(&ip_set_ref_lock);
932         swap(from->ref, to->ref);
933         ip_set_list[from_id] = to;
934         ip_set_list[to_id] = from;
935         write_unlock_bh(&ip_set_ref_lock);
936
937         return 0;
938 }
939
940 /* List/save set data */
941
942 #define DUMP_INIT       0L
943 #define DUMP_ALL        1L
944 #define DUMP_ONE        2L
945 #define DUMP_LAST       3L
946
947 static int
948 ip_set_dump_done(struct netlink_callback *cb)
949 {
950         if (cb->args[2]) {
951                 pr_debug("release set %s\n", ip_set_list[cb->args[1]]->name);
952                 ip_set_put_byindex((ip_set_id_t) cb->args[1]);
953         }
954         return 0;
955 }
956
957 static inline void
958 dump_attrs(struct nlmsghdr *nlh)
959 {
960         const struct nlattr *attr;
961         int rem;
962
963         pr_debug("dump nlmsg\n");
964         nlmsg_for_each_attr(attr, nlh, sizeof(struct nfgenmsg), rem) {
965                 pr_debug("type: %u, len %u\n", nla_type(attr), attr->nla_len);
966         }
967 }
968
969 static int
970 dump_init(struct netlink_callback *cb)
971 {
972         struct nlmsghdr *nlh = nlmsg_hdr(cb->skb);
973         int min_len = NLMSG_SPACE(sizeof(struct nfgenmsg));
974         struct nlattr *cda[IPSET_ATTR_CMD_MAX+1];
975         struct nlattr *attr = (void *)nlh + min_len;
976         ip_set_id_t index;
977
978         /* Second pass, so parser can't fail */
979         nla_parse(cda, IPSET_ATTR_CMD_MAX,
980                   attr, nlh->nlmsg_len - min_len, ip_set_setname_policy);
981
982         /* cb->args[0] : dump single set/all sets
983          *         [1] : set index
984          *         [..]: type specific
985          */
986
987         if (!cda[IPSET_ATTR_SETNAME]) {
988                 cb->args[0] = DUMP_ALL;
989                 return 0;
990         }
991
992         index = find_set_id(nla_data(cda[IPSET_ATTR_SETNAME]));
993         if (index == IPSET_INVALID_ID)
994                 return -ENOENT;
995
996         cb->args[0] = DUMP_ONE;
997         cb->args[1] = index;
998         return 0;
999 }
1000
1001 static int
1002 ip_set_dump_start(struct sk_buff *skb, struct netlink_callback *cb)
1003 {
1004         ip_set_id_t index = IPSET_INVALID_ID, max;
1005         struct ip_set *set = NULL;
1006         struct nlmsghdr *nlh = NULL;
1007         unsigned int flags = NETLINK_CB(cb->skb).pid ? NLM_F_MULTI : 0;
1008         int ret = 0;
1009
1010         if (cb->args[0] == DUMP_INIT) {
1011                 ret = dump_init(cb);
1012                 if (ret < 0) {
1013                         nlh = nlmsg_hdr(cb->skb);
1014                         /* We have to create and send the error message
1015                          * manually :-( */
1016                         if (nlh->nlmsg_flags & NLM_F_ACK)
1017                                 netlink_ack(cb->skb, nlh, ret);
1018                         return ret;
1019                 }
1020         }
1021
1022         if (cb->args[1] >= ip_set_max)
1023                 goto out;
1024
1025         pr_debug("args[0]: %ld args[1]: %ld\n", cb->args[0], cb->args[1]);
1026         max = cb->args[0] == DUMP_ONE ? cb->args[1] + 1 : ip_set_max;
1027         for (; cb->args[1] < max; cb->args[1]++) {
1028                 index = (ip_set_id_t) cb->args[1];
1029                 set = ip_set_list[index];
1030                 if (set == NULL) {
1031                         if (cb->args[0] == DUMP_ONE) {
1032                                 ret = -ENOENT;
1033                                 goto out;
1034                         }
1035                         continue;
1036                 }
1037                 /* When dumping all sets, we must dump "sorted"
1038                  * so that lists (unions of sets) are dumped last.
1039                  */
1040                 if (cb->args[0] != DUMP_ONE &&
1041                     !((cb->args[0] == DUMP_ALL) ^
1042                       (set->type->features & IPSET_DUMP_LAST)))
1043                         continue;
1044                 pr_debug("List set: %s\n", set->name);
1045                 if (!cb->args[2]) {
1046                         /* Start listing: make sure set won't be destroyed */
1047                         pr_debug("reference set\n");
1048                         __ip_set_get(index);
1049                 }
1050                 nlh = start_msg(skb, NETLINK_CB(cb->skb).pid,
1051                                 cb->nlh->nlmsg_seq, flags,
1052                                 IPSET_CMD_LIST);
1053                 if (!nlh) {
1054                         ret = -EMSGSIZE;
1055                         goto release_refcount;
1056                 }
1057                 NLA_PUT_U8(skb, IPSET_ATTR_PROTOCOL, IPSET_PROTOCOL);
1058                 NLA_PUT_STRING(skb, IPSET_ATTR_SETNAME, set->name);
1059                 switch (cb->args[2]) {
1060                 case 0:
1061                         /* Core header data */
1062                         NLA_PUT_STRING(skb, IPSET_ATTR_TYPENAME,
1063                                        set->type->name);
1064                         NLA_PUT_U8(skb, IPSET_ATTR_FAMILY,
1065                                    set->family);
1066                         NLA_PUT_U8(skb, IPSET_ATTR_REVISION,
1067                                    set->type->revision);
1068                         ret = set->variant->head(set, skb);
1069                         if (ret < 0)
1070                                 goto release_refcount;
1071                         /* Fall through and add elements */
1072                 default:
1073                         read_lock_bh(&set->lock);
1074                         ret = set->variant->list(set, skb, cb);
1075                         read_unlock_bh(&set->lock);
1076                         if (!cb->args[2]) {
1077                                 /* Set is done, proceed with next one */
1078                                 if (cb->args[0] == DUMP_ONE)
1079                                         cb->args[1] = IPSET_INVALID_ID;
1080                                 else
1081                                         cb->args[1]++;
1082                         }
1083                         goto release_refcount;
1084                 }
1085         }
1086         goto out;
1087
1088 nla_put_failure:
1089         ret = -EFAULT;
1090 release_refcount:
1091         /* If there was an error or set is done, release set */
1092         if (ret || !cb->args[2]) {
1093                 pr_debug("release set %s\n", ip_set_list[index]->name);
1094                 ip_set_put_byindex(index);
1095         }
1096
1097         /* If we dump all sets, continue with dumping last ones */
1098         if (cb->args[0] == DUMP_ALL && cb->args[1] >= max && !cb->args[2])
1099                 cb->args[0] = DUMP_LAST;
1100
1101 out:
1102         if (nlh) {
1103                 nlmsg_end(skb, nlh);
1104                 pr_debug("nlmsg_len: %u\n", nlh->nlmsg_len);
1105                 dump_attrs(nlh);
1106         }
1107
1108         return ret < 0 ? ret : skb->len;
1109 }
1110
1111 static int
1112 ip_set_dump(struct sock *ctnl, struct sk_buff *skb,
1113             const struct nlmsghdr *nlh,
1114             const struct nlattr * const attr[])
1115 {
1116         if (unlikely(protocol_failed(attr)))
1117                 return -IPSET_ERR_PROTOCOL;
1118
1119         return netlink_dump_start(ctnl, skb, nlh,
1120                                   ip_set_dump_start,
1121                                   ip_set_dump_done);
1122 }
1123
1124 /* Add, del and test */
1125
1126 static const struct nla_policy ip_set_adt_policy[IPSET_ATTR_CMD_MAX + 1] = {
1127         [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
1128         [IPSET_ATTR_SETNAME]    = { .type = NLA_NUL_STRING,
1129                                     .len = IPSET_MAXNAMELEN - 1 },
1130         [IPSET_ATTR_LINENO]     = { .type = NLA_U32 },
1131         [IPSET_ATTR_DATA]       = { .type = NLA_NESTED },
1132         [IPSET_ATTR_ADT]        = { .type = NLA_NESTED },
1133 };
1134
1135 static int
1136 call_ad(struct sock *ctnl, struct sk_buff *skb, struct ip_set *set,
1137         struct nlattr *tb[], enum ipset_adt adt,
1138         u32 flags, bool use_lineno)
1139 {
1140         int ret, retried = 0;
1141         u32 lineno = 0;
1142         bool eexist = flags & IPSET_FLAG_EXIST;
1143
1144         do {
1145                 write_lock_bh(&set->lock);
1146                 ret = set->variant->uadt(set, tb, adt, &lineno, flags);
1147                 write_unlock_bh(&set->lock);
1148         } while (ret == -EAGAIN &&
1149                  set->variant->resize &&
1150                  (ret = set->variant->resize(set, retried++)) == 0);
1151
1152         if (!ret || (ret == -IPSET_ERR_EXIST && eexist))
1153                 return 0;
1154         if (lineno && use_lineno) {
1155                 /* Error in restore/batch mode: send back lineno */
1156                 struct nlmsghdr *rep, *nlh = nlmsg_hdr(skb);
1157                 struct sk_buff *skb2;
1158                 struct nlmsgerr *errmsg;
1159                 size_t payload = sizeof(*errmsg) + nlmsg_len(nlh);
1160                 int min_len = NLMSG_SPACE(sizeof(struct nfgenmsg));
1161                 struct nlattr *cda[IPSET_ATTR_CMD_MAX+1];
1162                 struct nlattr *cmdattr;
1163                 u32 *errline;
1164
1165                 skb2 = nlmsg_new(payload, GFP_KERNEL);
1166                 if (skb2 == NULL)
1167                         return -ENOMEM;
1168                 rep = __nlmsg_put(skb2, NETLINK_CB(skb).pid,
1169                                   nlh->nlmsg_seq, NLMSG_ERROR, payload, 0);
1170                 errmsg = nlmsg_data(rep);
1171                 errmsg->error = ret;
1172                 memcpy(&errmsg->msg, nlh, nlh->nlmsg_len);
1173                 cmdattr = (void *)&errmsg->msg + min_len;
1174
1175                 nla_parse(cda, IPSET_ATTR_CMD_MAX,
1176                           cmdattr, nlh->nlmsg_len - min_len,
1177                           ip_set_adt_policy);
1178
1179                 errline = nla_data(cda[IPSET_ATTR_LINENO]);
1180
1181                 *errline = lineno;
1182
1183                 netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1184                 /* Signal netlink not to send its ACK/errmsg.  */
1185                 return -EINTR;
1186         }
1187
1188         return ret;
1189 }
1190
1191 static int
1192 ip_set_uadd(struct sock *ctnl, struct sk_buff *skb,
1193             const struct nlmsghdr *nlh,
1194             const struct nlattr * const attr[])
1195 {
1196         struct ip_set *set;
1197         struct nlattr *tb[IPSET_ATTR_ADT_MAX+1] = {};
1198         const struct nlattr *nla;
1199         u32 flags = flag_exist(nlh);
1200         bool use_lineno;
1201         int ret = 0;
1202
1203         if (unlikely(protocol_failed(attr) ||
1204                      attr[IPSET_ATTR_SETNAME] == NULL ||
1205                      !((attr[IPSET_ATTR_DATA] != NULL) ^
1206                        (attr[IPSET_ATTR_ADT] != NULL)) ||
1207                      (attr[IPSET_ATTR_DATA] != NULL &&
1208                       !flag_nested(attr[IPSET_ATTR_DATA])) ||
1209                      (attr[IPSET_ATTR_ADT] != NULL &&
1210                       (!flag_nested(attr[IPSET_ATTR_ADT]) ||
1211                        attr[IPSET_ATTR_LINENO] == NULL))))
1212                 return -IPSET_ERR_PROTOCOL;
1213
1214         set = find_set(nla_data(attr[IPSET_ATTR_SETNAME]));
1215         if (set == NULL)
1216                 return -ENOENT;
1217
1218         use_lineno = !!attr[IPSET_ATTR_LINENO];
1219         if (attr[IPSET_ATTR_DATA]) {
1220                 if (nla_parse_nested(tb, IPSET_ATTR_ADT_MAX,
1221                                      attr[IPSET_ATTR_DATA],
1222                                      set->type->adt_policy))
1223                         return -IPSET_ERR_PROTOCOL;
1224                 ret = call_ad(ctnl, skb, set, tb, IPSET_ADD, flags,
1225                               use_lineno);
1226         } else {
1227                 int nla_rem;
1228
1229                 nla_for_each_nested(nla, attr[IPSET_ATTR_ADT], nla_rem) {
1230                         memset(tb, 0, sizeof(tb));
1231                         if (nla_type(nla) != IPSET_ATTR_DATA ||
1232                             !flag_nested(nla) ||
1233                             nla_parse_nested(tb, IPSET_ATTR_ADT_MAX, nla,
1234                                              set->type->adt_policy))
1235                                 return -IPSET_ERR_PROTOCOL;
1236                         ret = call_ad(ctnl, skb, set, tb, IPSET_ADD,
1237                                       flags, use_lineno);
1238                         if (ret < 0)
1239                                 return ret;
1240                 }
1241         }
1242         return ret;
1243 }
1244
1245 static int
1246 ip_set_udel(struct sock *ctnl, struct sk_buff *skb,
1247             const struct nlmsghdr *nlh,
1248             const struct nlattr * const attr[])
1249 {
1250         struct ip_set *set;
1251         struct nlattr *tb[IPSET_ATTR_ADT_MAX+1] = {};
1252         const struct nlattr *nla;
1253         u32 flags = flag_exist(nlh);
1254         bool use_lineno;
1255         int ret = 0;
1256
1257         if (unlikely(protocol_failed(attr) ||
1258                      attr[IPSET_ATTR_SETNAME] == NULL ||
1259                      !((attr[IPSET_ATTR_DATA] != NULL) ^
1260                        (attr[IPSET_ATTR_ADT] != NULL)) ||
1261                      (attr[IPSET_ATTR_DATA] != NULL &&
1262                       !flag_nested(attr[IPSET_ATTR_DATA])) ||
1263                      (attr[IPSET_ATTR_ADT] != NULL &&
1264                       (!flag_nested(attr[IPSET_ATTR_ADT]) ||
1265                        attr[IPSET_ATTR_LINENO] == NULL))))
1266                 return -IPSET_ERR_PROTOCOL;
1267
1268         set = find_set(nla_data(attr[IPSET_ATTR_SETNAME]));
1269         if (set == NULL)
1270                 return -ENOENT;
1271
1272         use_lineno = !!attr[IPSET_ATTR_LINENO];
1273         if (attr[IPSET_ATTR_DATA]) {
1274                 if (nla_parse_nested(tb, IPSET_ATTR_ADT_MAX,
1275                                      attr[IPSET_ATTR_DATA],
1276                                      set->type->adt_policy))
1277                         return -IPSET_ERR_PROTOCOL;
1278                 ret = call_ad(ctnl, skb, set, tb, IPSET_DEL, flags,
1279                               use_lineno);
1280         } else {
1281                 int nla_rem;
1282
1283                 nla_for_each_nested(nla, attr[IPSET_ATTR_ADT], nla_rem) {
1284                         memset(tb, 0, sizeof(*tb));
1285                         if (nla_type(nla) != IPSET_ATTR_DATA ||
1286                             !flag_nested(nla) ||
1287                             nla_parse_nested(tb, IPSET_ATTR_ADT_MAX, nla,
1288                                              set->type->adt_policy))
1289                                 return -IPSET_ERR_PROTOCOL;
1290                         ret = call_ad(ctnl, skb, set, tb, IPSET_DEL,
1291                                       flags, use_lineno);
1292                         if (ret < 0)
1293                                 return ret;
1294                 }
1295         }
1296         return ret;
1297 }
1298
1299 static int
1300 ip_set_utest(struct sock *ctnl, struct sk_buff *skb,
1301              const struct nlmsghdr *nlh,
1302              const struct nlattr * const attr[])
1303 {
1304         struct ip_set *set;
1305         struct nlattr *tb[IPSET_ATTR_ADT_MAX+1] = {};
1306         int ret = 0;
1307
1308         if (unlikely(protocol_failed(attr) ||
1309                      attr[IPSET_ATTR_SETNAME] == NULL ||
1310                      attr[IPSET_ATTR_DATA] == NULL ||
1311                      !flag_nested(attr[IPSET_ATTR_DATA])))
1312                 return -IPSET_ERR_PROTOCOL;
1313
1314         set = find_set(nla_data(attr[IPSET_ATTR_SETNAME]));
1315         if (set == NULL)
1316                 return -ENOENT;
1317
1318         if (nla_parse_nested(tb, IPSET_ATTR_ADT_MAX, attr[IPSET_ATTR_DATA],
1319                              set->type->adt_policy))
1320                 return -IPSET_ERR_PROTOCOL;
1321
1322         read_lock_bh(&set->lock);
1323         ret = set->variant->uadt(set, tb, IPSET_TEST, NULL, 0);
1324         read_unlock_bh(&set->lock);
1325         /* Userspace can't trigger element to be re-added */
1326         if (ret == -EAGAIN)
1327                 ret = 1;
1328
1329         return ret < 0 ? ret : ret > 0 ? 0 : -IPSET_ERR_EXIST;
1330 }
1331
1332 /* Get headed data of a set */
1333
1334 static int
1335 ip_set_header(struct sock *ctnl, struct sk_buff *skb,
1336               const struct nlmsghdr *nlh,
1337               const struct nlattr * const attr[])
1338 {
1339         const struct ip_set *set;
1340         struct sk_buff *skb2;
1341         struct nlmsghdr *nlh2;
1342         ip_set_id_t index;
1343         int ret = 0;
1344
1345         if (unlikely(protocol_failed(attr) ||
1346                      attr[IPSET_ATTR_SETNAME] == NULL))
1347                 return -IPSET_ERR_PROTOCOL;
1348
1349         index = find_set_id(nla_data(attr[IPSET_ATTR_SETNAME]));
1350         if (index == IPSET_INVALID_ID)
1351                 return -ENOENT;
1352         set = ip_set_list[index];
1353
1354         skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1355         if (skb2 == NULL)
1356                 return -ENOMEM;
1357
1358         nlh2 = start_msg(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq, 0,
1359                          IPSET_CMD_HEADER);
1360         if (!nlh2)
1361                 goto nlmsg_failure;
1362         NLA_PUT_U8(skb2, IPSET_ATTR_PROTOCOL, IPSET_PROTOCOL);
1363         NLA_PUT_STRING(skb2, IPSET_ATTR_SETNAME, set->name);
1364         NLA_PUT_STRING(skb2, IPSET_ATTR_TYPENAME, set->type->name);
1365         NLA_PUT_U8(skb2, IPSET_ATTR_FAMILY, set->family);
1366         NLA_PUT_U8(skb2, IPSET_ATTR_REVISION, set->type->revision);
1367         nlmsg_end(skb2, nlh2);
1368
1369         ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1370         if (ret < 0)
1371                 return ret;
1372
1373         return 0;
1374
1375 nla_put_failure:
1376         nlmsg_cancel(skb2, nlh2);
1377 nlmsg_failure:
1378         kfree_skb(skb2);
1379         return -EMSGSIZE;
1380 }
1381
1382 /* Get type data */
1383
1384 static const struct nla_policy ip_set_type_policy[IPSET_ATTR_CMD_MAX + 1] = {
1385         [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
1386         [IPSET_ATTR_TYPENAME]   = { .type = NLA_NUL_STRING,
1387                                     .len = IPSET_MAXNAMELEN - 1 },
1388         [IPSET_ATTR_FAMILY]     = { .type = NLA_U8 },
1389 };
1390
1391 static int
1392 ip_set_type(struct sock *ctnl, struct sk_buff *skb,
1393             const struct nlmsghdr *nlh,
1394             const struct nlattr * const attr[])
1395 {
1396         struct sk_buff *skb2;
1397         struct nlmsghdr *nlh2;
1398         u8 family, min, max;
1399         const char *typename;
1400         int ret = 0;
1401
1402         if (unlikely(protocol_failed(attr) ||
1403                      attr[IPSET_ATTR_TYPENAME] == NULL ||
1404                      attr[IPSET_ATTR_FAMILY] == NULL))
1405                 return -IPSET_ERR_PROTOCOL;
1406
1407         family = nla_get_u8(attr[IPSET_ATTR_FAMILY]);
1408         typename = nla_data(attr[IPSET_ATTR_TYPENAME]);
1409         ret = find_set_type_minmax(typename, family, &min, &max);
1410         if (ret)
1411                 return ret;
1412
1413         skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1414         if (skb2 == NULL)
1415                 return -ENOMEM;
1416
1417         nlh2 = start_msg(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq, 0,
1418                          IPSET_CMD_TYPE);
1419         if (!nlh2)
1420                 goto nlmsg_failure;
1421         NLA_PUT_U8(skb2, IPSET_ATTR_PROTOCOL, IPSET_PROTOCOL);
1422         NLA_PUT_STRING(skb2, IPSET_ATTR_TYPENAME, typename);
1423         NLA_PUT_U8(skb2, IPSET_ATTR_FAMILY, family);
1424         NLA_PUT_U8(skb2, IPSET_ATTR_REVISION, max);
1425         NLA_PUT_U8(skb2, IPSET_ATTR_REVISION_MIN, min);
1426         nlmsg_end(skb2, nlh2);
1427
1428         pr_debug("Send TYPE, nlmsg_len: %u\n", nlh2->nlmsg_len);
1429         ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1430         if (ret < 0)
1431                 return ret;
1432
1433         return 0;
1434
1435 nla_put_failure:
1436         nlmsg_cancel(skb2, nlh2);
1437 nlmsg_failure:
1438         kfree_skb(skb2);
1439         return -EMSGSIZE;
1440 }
1441
1442 /* Get protocol version */
1443
1444 static const struct nla_policy
1445 ip_set_protocol_policy[IPSET_ATTR_CMD_MAX + 1] = {
1446         [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
1447 };
1448
1449 static int
1450 ip_set_protocol(struct sock *ctnl, struct sk_buff *skb,
1451                 const struct nlmsghdr *nlh,
1452                 const struct nlattr * const attr[])
1453 {
1454         struct sk_buff *skb2;
1455         struct nlmsghdr *nlh2;
1456         int ret = 0;
1457
1458         if (unlikely(attr[IPSET_ATTR_PROTOCOL] == NULL))
1459                 return -IPSET_ERR_PROTOCOL;
1460
1461         skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1462         if (skb2 == NULL)
1463                 return -ENOMEM;
1464
1465         nlh2 = start_msg(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq, 0,
1466                          IPSET_CMD_PROTOCOL);
1467         if (!nlh2)
1468                 goto nlmsg_failure;
1469         NLA_PUT_U8(skb2, IPSET_ATTR_PROTOCOL, IPSET_PROTOCOL);
1470         nlmsg_end(skb2, nlh2);
1471
1472         ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1473         if (ret < 0)
1474                 return ret;
1475
1476         return 0;
1477
1478 nla_put_failure:
1479         nlmsg_cancel(skb2, nlh2);
1480 nlmsg_failure:
1481         kfree_skb(skb2);
1482         return -EMSGSIZE;
1483 }
1484
1485 static const struct nfnl_callback ip_set_netlink_subsys_cb[IPSET_MSG_MAX] = {
1486         [IPSET_CMD_CREATE]      = {
1487                 .call           = ip_set_create,
1488                 .attr_count     = IPSET_ATTR_CMD_MAX,
1489                 .policy         = ip_set_create_policy,
1490         },
1491         [IPSET_CMD_DESTROY]     = {
1492                 .call           = ip_set_destroy,
1493                 .attr_count     = IPSET_ATTR_CMD_MAX,
1494                 .policy         = ip_set_setname_policy,
1495         },
1496         [IPSET_CMD_FLUSH]       = {
1497                 .call           = ip_set_flush,
1498                 .attr_count     = IPSET_ATTR_CMD_MAX,
1499                 .policy         = ip_set_setname_policy,
1500         },
1501         [IPSET_CMD_RENAME]      = {
1502                 .call           = ip_set_rename,
1503                 .attr_count     = IPSET_ATTR_CMD_MAX,
1504                 .policy         = ip_set_setname2_policy,
1505         },
1506         [IPSET_CMD_SWAP]        = {
1507                 .call           = ip_set_swap,
1508                 .attr_count     = IPSET_ATTR_CMD_MAX,
1509                 .policy         = ip_set_setname2_policy,
1510         },
1511         [IPSET_CMD_LIST]        = {
1512                 .call           = ip_set_dump,
1513                 .attr_count     = IPSET_ATTR_CMD_MAX,
1514                 .policy         = ip_set_setname_policy,
1515         },
1516         [IPSET_CMD_SAVE]        = {
1517                 .call           = ip_set_dump,
1518                 .attr_count     = IPSET_ATTR_CMD_MAX,
1519                 .policy         = ip_set_setname_policy,
1520         },
1521         [IPSET_CMD_ADD] = {
1522                 .call           = ip_set_uadd,
1523                 .attr_count     = IPSET_ATTR_CMD_MAX,
1524                 .policy         = ip_set_adt_policy,
1525         },
1526         [IPSET_CMD_DEL] = {
1527                 .call           = ip_set_udel,
1528                 .attr_count     = IPSET_ATTR_CMD_MAX,
1529                 .policy         = ip_set_adt_policy,
1530         },
1531         [IPSET_CMD_TEST]        = {
1532                 .call           = ip_set_utest,
1533                 .attr_count     = IPSET_ATTR_CMD_MAX,
1534                 .policy         = ip_set_adt_policy,
1535         },
1536         [IPSET_CMD_HEADER]      = {
1537                 .call           = ip_set_header,
1538                 .attr_count     = IPSET_ATTR_CMD_MAX,
1539                 .policy         = ip_set_setname_policy,
1540         },
1541         [IPSET_CMD_TYPE]        = {
1542                 .call           = ip_set_type,
1543                 .attr_count     = IPSET_ATTR_CMD_MAX,
1544                 .policy         = ip_set_type_policy,
1545         },
1546         [IPSET_CMD_PROTOCOL]    = {
1547                 .call           = ip_set_protocol,
1548                 .attr_count     = IPSET_ATTR_CMD_MAX,
1549                 .policy         = ip_set_protocol_policy,
1550         },
1551 };
1552
1553 static struct nfnetlink_subsystem ip_set_netlink_subsys __read_mostly = {
1554         .name           = "ip_set",
1555         .subsys_id      = NFNL_SUBSYS_IPSET,
1556         .cb_count       = IPSET_MSG_MAX,
1557         .cb             = ip_set_netlink_subsys_cb,
1558 };
1559
1560 /* Interface to iptables/ip6tables */
1561
1562 static int
1563 ip_set_sockfn_get(struct sock *sk, int optval, void __user *user, int *len)
1564 {
1565         unsigned *op;
1566         void *data;
1567         int copylen = *len, ret = 0;
1568
1569         if (!capable(CAP_NET_ADMIN))
1570                 return -EPERM;
1571         if (optval != SO_IP_SET)
1572                 return -EBADF;
1573         if (*len < sizeof(unsigned))
1574                 return -EINVAL;
1575
1576         data = vmalloc(*len);
1577         if (!data)
1578                 return -ENOMEM;
1579         if (copy_from_user(data, user, *len) != 0) {
1580                 ret = -EFAULT;
1581                 goto done;
1582         }
1583         op = (unsigned *) data;
1584
1585         if (*op < IP_SET_OP_VERSION) {
1586                 /* Check the version at the beginning of operations */
1587                 struct ip_set_req_version *req_version = data;
1588                 if (req_version->version != IPSET_PROTOCOL) {
1589                         ret = -EPROTO;
1590                         goto done;
1591                 }
1592         }
1593
1594         switch (*op) {
1595         case IP_SET_OP_VERSION: {
1596                 struct ip_set_req_version *req_version = data;
1597
1598                 if (*len != sizeof(struct ip_set_req_version)) {
1599                         ret = -EINVAL;
1600                         goto done;
1601                 }
1602
1603                 req_version->version = IPSET_PROTOCOL;
1604                 ret = copy_to_user(user, req_version,
1605                                    sizeof(struct ip_set_req_version));
1606                 goto done;
1607         }
1608         case IP_SET_OP_GET_BYNAME: {
1609                 struct ip_set_req_get_set *req_get = data;
1610
1611                 if (*len != sizeof(struct ip_set_req_get_set)) {
1612                         ret = -EINVAL;
1613                         goto done;
1614                 }
1615                 req_get->set.name[IPSET_MAXNAMELEN - 1] = '\0';
1616                 nfnl_lock();
1617                 req_get->set.index = find_set_id(req_get->set.name);
1618                 nfnl_unlock();
1619                 goto copy;
1620         }
1621         case IP_SET_OP_GET_BYINDEX: {
1622                 struct ip_set_req_get_set *req_get = data;
1623
1624                 if (*len != sizeof(struct ip_set_req_get_set) ||
1625                     req_get->set.index >= ip_set_max) {
1626                         ret = -EINVAL;
1627                         goto done;
1628                 }
1629                 nfnl_lock();
1630                 strncpy(req_get->set.name,
1631                         ip_set_list[req_get->set.index]
1632                                 ? ip_set_list[req_get->set.index]->name : "",
1633                         IPSET_MAXNAMELEN);
1634                 nfnl_unlock();
1635                 goto copy;
1636         }
1637         default:
1638                 ret = -EBADMSG;
1639                 goto done;
1640         }       /* end of switch(op) */
1641
1642 copy:
1643         ret = copy_to_user(user, data, copylen);
1644
1645 done:
1646         vfree(data);
1647         if (ret > 0)
1648                 ret = 0;
1649         return ret;
1650 }
1651
1652 static struct nf_sockopt_ops so_set __read_mostly = {
1653         .pf             = PF_INET,
1654         .get_optmin     = SO_IP_SET,
1655         .get_optmax     = SO_IP_SET + 1,
1656         .get            = &ip_set_sockfn_get,
1657         .owner          = THIS_MODULE,
1658 };
1659
1660 static int __init
1661 ip_set_init(void)
1662 {
1663         int ret;
1664
1665         if (max_sets)
1666                 ip_set_max = max_sets;
1667         if (ip_set_max >= IPSET_INVALID_ID)
1668                 ip_set_max = IPSET_INVALID_ID - 1;
1669
1670         ip_set_list = kzalloc(sizeof(struct ip_set *) * ip_set_max,
1671                               GFP_KERNEL);
1672         if (!ip_set_list) {
1673                 pr_err("ip_set: Unable to create ip_set_list\n");
1674                 return -ENOMEM;
1675         }
1676
1677         ret = nfnetlink_subsys_register(&ip_set_netlink_subsys);
1678         if (ret != 0) {
1679                 pr_err("ip_set: cannot register with nfnetlink.\n");
1680                 kfree(ip_set_list);
1681                 return ret;
1682         }
1683         ret = nf_register_sockopt(&so_set);
1684         if (ret != 0) {
1685                 pr_err("SO_SET registry failed: %d\n", ret);
1686                 nfnetlink_subsys_unregister(&ip_set_netlink_subsys);
1687                 kfree(ip_set_list);
1688                 return ret;
1689         }
1690
1691         pr_notice("ip_set: protocol %u\n", IPSET_PROTOCOL);
1692         return 0;
1693 }
1694
1695 static void __exit
1696 ip_set_fini(void)
1697 {
1698         /* There can't be any existing set */
1699         nf_unregister_sockopt(&so_set);
1700         nfnetlink_subsys_unregister(&ip_set_netlink_subsys);
1701         kfree(ip_set_list);
1702         pr_debug("these are the famous last words\n");
1703 }
1704
1705 module_init(ip_set_init);
1706 module_exit(ip_set_fini);