Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/kaber/nf-2.6
[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 artificial 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         max = cb->args[0] == DUMP_ONE ? cb->args[1] + 1 : ip_set_max;
1026 dump_last:
1027         pr_debug("args[0]: %ld args[1]: %ld\n", cb->args[0], cb->args[1]);
1028         for (; cb->args[1] < max; cb->args[1]++) {
1029                 index = (ip_set_id_t) cb->args[1];
1030                 set = ip_set_list[index];
1031                 if (set == NULL) {
1032                         if (cb->args[0] == DUMP_ONE) {
1033                                 ret = -ENOENT;
1034                                 goto out;
1035                         }
1036                         continue;
1037                 }
1038                 /* When dumping all sets, we must dump "sorted"
1039                  * so that lists (unions of sets) are dumped last.
1040                  */
1041                 if (cb->args[0] != DUMP_ONE &&
1042                     ((cb->args[0] == DUMP_ALL) ==
1043                      !!(set->type->features & IPSET_DUMP_LAST)))
1044                         continue;
1045                 pr_debug("List set: %s\n", set->name);
1046                 if (!cb->args[2]) {
1047                         /* Start listing: make sure set won't be destroyed */
1048                         pr_debug("reference set\n");
1049                         __ip_set_get(index);
1050                 }
1051                 nlh = start_msg(skb, NETLINK_CB(cb->skb).pid,
1052                                 cb->nlh->nlmsg_seq, flags,
1053                                 IPSET_CMD_LIST);
1054                 if (!nlh) {
1055                         ret = -EMSGSIZE;
1056                         goto release_refcount;
1057                 }
1058                 NLA_PUT_U8(skb, IPSET_ATTR_PROTOCOL, IPSET_PROTOCOL);
1059                 NLA_PUT_STRING(skb, IPSET_ATTR_SETNAME, set->name);
1060                 switch (cb->args[2]) {
1061                 case 0:
1062                         /* Core header data */
1063                         NLA_PUT_STRING(skb, IPSET_ATTR_TYPENAME,
1064                                        set->type->name);
1065                         NLA_PUT_U8(skb, IPSET_ATTR_FAMILY,
1066                                    set->family);
1067                         NLA_PUT_U8(skb, IPSET_ATTR_REVISION,
1068                                    set->type->revision);
1069                         ret = set->variant->head(set, skb);
1070                         if (ret < 0)
1071                                 goto release_refcount;
1072                         /* Fall through and add elements */
1073                 default:
1074                         read_lock_bh(&set->lock);
1075                         ret = set->variant->list(set, skb, cb);
1076                         read_unlock_bh(&set->lock);
1077                         if (!cb->args[2]) {
1078                                 /* Set is done, proceed with next one */
1079                                 if (cb->args[0] == DUMP_ONE)
1080                                         cb->args[1] = IPSET_INVALID_ID;
1081                                 else
1082                                         cb->args[1]++;
1083                         }
1084                         goto release_refcount;
1085                 }
1086         }
1087         /* If we dump all sets, continue with dumping last ones */
1088         if (cb->args[0] == DUMP_ALL) {
1089                 cb->args[0] = DUMP_LAST;
1090                 cb->args[1] = 0;
1091                 goto dump_last;
1092         }
1093         goto out;
1094
1095 nla_put_failure:
1096         ret = -EFAULT;
1097 release_refcount:
1098         /* If there was an error or set is done, release set */
1099         if (ret || !cb->args[2]) {
1100                 pr_debug("release set %s\n", ip_set_list[index]->name);
1101                 ip_set_put_byindex(index);
1102         }
1103 out:
1104         if (nlh) {
1105                 nlmsg_end(skb, nlh);
1106                 pr_debug("nlmsg_len: %u\n", nlh->nlmsg_len);
1107                 dump_attrs(nlh);
1108         }
1109
1110         return ret < 0 ? ret : skb->len;
1111 }
1112
1113 static int
1114 ip_set_dump(struct sock *ctnl, struct sk_buff *skb,
1115             const struct nlmsghdr *nlh,
1116             const struct nlattr * const attr[])
1117 {
1118         if (unlikely(protocol_failed(attr)))
1119                 return -IPSET_ERR_PROTOCOL;
1120
1121         return netlink_dump_start(ctnl, skb, nlh,
1122                                   ip_set_dump_start,
1123                                   ip_set_dump_done);
1124 }
1125
1126 /* Add, del and test */
1127
1128 static const struct nla_policy ip_set_adt_policy[IPSET_ATTR_CMD_MAX + 1] = {
1129         [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
1130         [IPSET_ATTR_SETNAME]    = { .type = NLA_NUL_STRING,
1131                                     .len = IPSET_MAXNAMELEN - 1 },
1132         [IPSET_ATTR_LINENO]     = { .type = NLA_U32 },
1133         [IPSET_ATTR_DATA]       = { .type = NLA_NESTED },
1134         [IPSET_ATTR_ADT]        = { .type = NLA_NESTED },
1135 };
1136
1137 static int
1138 call_ad(struct sock *ctnl, struct sk_buff *skb, struct ip_set *set,
1139         struct nlattr *tb[], enum ipset_adt adt,
1140         u32 flags, bool use_lineno)
1141 {
1142         int ret, retried = 0;
1143         u32 lineno = 0;
1144         bool eexist = flags & IPSET_FLAG_EXIST;
1145
1146         do {
1147                 write_lock_bh(&set->lock);
1148                 ret = set->variant->uadt(set, tb, adt, &lineno, flags);
1149                 write_unlock_bh(&set->lock);
1150         } while (ret == -EAGAIN &&
1151                  set->variant->resize &&
1152                  (ret = set->variant->resize(set, retried++)) == 0);
1153
1154         if (!ret || (ret == -IPSET_ERR_EXIST && eexist))
1155                 return 0;
1156         if (lineno && use_lineno) {
1157                 /* Error in restore/batch mode: send back lineno */
1158                 struct nlmsghdr *rep, *nlh = nlmsg_hdr(skb);
1159                 struct sk_buff *skb2;
1160                 struct nlmsgerr *errmsg;
1161                 size_t payload = sizeof(*errmsg) + nlmsg_len(nlh);
1162                 int min_len = NLMSG_SPACE(sizeof(struct nfgenmsg));
1163                 struct nlattr *cda[IPSET_ATTR_CMD_MAX+1];
1164                 struct nlattr *cmdattr;
1165                 u32 *errline;
1166
1167                 skb2 = nlmsg_new(payload, GFP_KERNEL);
1168                 if (skb2 == NULL)
1169                         return -ENOMEM;
1170                 rep = __nlmsg_put(skb2, NETLINK_CB(skb).pid,
1171                                   nlh->nlmsg_seq, NLMSG_ERROR, payload, 0);
1172                 errmsg = nlmsg_data(rep);
1173                 errmsg->error = ret;
1174                 memcpy(&errmsg->msg, nlh, nlh->nlmsg_len);
1175                 cmdattr = (void *)&errmsg->msg + min_len;
1176
1177                 nla_parse(cda, IPSET_ATTR_CMD_MAX,
1178                           cmdattr, nlh->nlmsg_len - min_len,
1179                           ip_set_adt_policy);
1180
1181                 errline = nla_data(cda[IPSET_ATTR_LINENO]);
1182
1183                 *errline = lineno;
1184
1185                 netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1186                 /* Signal netlink not to send its ACK/errmsg.  */
1187                 return -EINTR;
1188         }
1189
1190         return ret;
1191 }
1192
1193 static int
1194 ip_set_uadd(struct sock *ctnl, struct sk_buff *skb,
1195             const struct nlmsghdr *nlh,
1196             const struct nlattr * const attr[])
1197 {
1198         struct ip_set *set;
1199         struct nlattr *tb[IPSET_ATTR_ADT_MAX+1] = {};
1200         const struct nlattr *nla;
1201         u32 flags = flag_exist(nlh);
1202         bool use_lineno;
1203         int ret = 0;
1204
1205         if (unlikely(protocol_failed(attr) ||
1206                      attr[IPSET_ATTR_SETNAME] == NULL ||
1207                      !((attr[IPSET_ATTR_DATA] != NULL) ^
1208                        (attr[IPSET_ATTR_ADT] != NULL)) ||
1209                      (attr[IPSET_ATTR_DATA] != NULL &&
1210                       !flag_nested(attr[IPSET_ATTR_DATA])) ||
1211                      (attr[IPSET_ATTR_ADT] != NULL &&
1212                       (!flag_nested(attr[IPSET_ATTR_ADT]) ||
1213                        attr[IPSET_ATTR_LINENO] == NULL))))
1214                 return -IPSET_ERR_PROTOCOL;
1215
1216         set = find_set(nla_data(attr[IPSET_ATTR_SETNAME]));
1217         if (set == NULL)
1218                 return -ENOENT;
1219
1220         use_lineno = !!attr[IPSET_ATTR_LINENO];
1221         if (attr[IPSET_ATTR_DATA]) {
1222                 if (nla_parse_nested(tb, IPSET_ATTR_ADT_MAX,
1223                                      attr[IPSET_ATTR_DATA],
1224                                      set->type->adt_policy))
1225                         return -IPSET_ERR_PROTOCOL;
1226                 ret = call_ad(ctnl, skb, set, tb, IPSET_ADD, flags,
1227                               use_lineno);
1228         } else {
1229                 int nla_rem;
1230
1231                 nla_for_each_nested(nla, attr[IPSET_ATTR_ADT], nla_rem) {
1232                         memset(tb, 0, sizeof(tb));
1233                         if (nla_type(nla) != IPSET_ATTR_DATA ||
1234                             !flag_nested(nla) ||
1235                             nla_parse_nested(tb, IPSET_ATTR_ADT_MAX, nla,
1236                                              set->type->adt_policy))
1237                                 return -IPSET_ERR_PROTOCOL;
1238                         ret = call_ad(ctnl, skb, set, tb, IPSET_ADD,
1239                                       flags, use_lineno);
1240                         if (ret < 0)
1241                                 return ret;
1242                 }
1243         }
1244         return ret;
1245 }
1246
1247 static int
1248 ip_set_udel(struct sock *ctnl, struct sk_buff *skb,
1249             const struct nlmsghdr *nlh,
1250             const struct nlattr * const attr[])
1251 {
1252         struct ip_set *set;
1253         struct nlattr *tb[IPSET_ATTR_ADT_MAX+1] = {};
1254         const struct nlattr *nla;
1255         u32 flags = flag_exist(nlh);
1256         bool use_lineno;
1257         int ret = 0;
1258
1259         if (unlikely(protocol_failed(attr) ||
1260                      attr[IPSET_ATTR_SETNAME] == NULL ||
1261                      !((attr[IPSET_ATTR_DATA] != NULL) ^
1262                        (attr[IPSET_ATTR_ADT] != NULL)) ||
1263                      (attr[IPSET_ATTR_DATA] != NULL &&
1264                       !flag_nested(attr[IPSET_ATTR_DATA])) ||
1265                      (attr[IPSET_ATTR_ADT] != NULL &&
1266                       (!flag_nested(attr[IPSET_ATTR_ADT]) ||
1267                        attr[IPSET_ATTR_LINENO] == NULL))))
1268                 return -IPSET_ERR_PROTOCOL;
1269
1270         set = find_set(nla_data(attr[IPSET_ATTR_SETNAME]));
1271         if (set == NULL)
1272                 return -ENOENT;
1273
1274         use_lineno = !!attr[IPSET_ATTR_LINENO];
1275         if (attr[IPSET_ATTR_DATA]) {
1276                 if (nla_parse_nested(tb, IPSET_ATTR_ADT_MAX,
1277                                      attr[IPSET_ATTR_DATA],
1278                                      set->type->adt_policy))
1279                         return -IPSET_ERR_PROTOCOL;
1280                 ret = call_ad(ctnl, skb, set, tb, IPSET_DEL, flags,
1281                               use_lineno);
1282         } else {
1283                 int nla_rem;
1284
1285                 nla_for_each_nested(nla, attr[IPSET_ATTR_ADT], nla_rem) {
1286                         memset(tb, 0, sizeof(*tb));
1287                         if (nla_type(nla) != IPSET_ATTR_DATA ||
1288                             !flag_nested(nla) ||
1289                             nla_parse_nested(tb, IPSET_ATTR_ADT_MAX, nla,
1290                                              set->type->adt_policy))
1291                                 return -IPSET_ERR_PROTOCOL;
1292                         ret = call_ad(ctnl, skb, set, tb, IPSET_DEL,
1293                                       flags, use_lineno);
1294                         if (ret < 0)
1295                                 return ret;
1296                 }
1297         }
1298         return ret;
1299 }
1300
1301 static int
1302 ip_set_utest(struct sock *ctnl, struct sk_buff *skb,
1303              const struct nlmsghdr *nlh,
1304              const struct nlattr * const attr[])
1305 {
1306         struct ip_set *set;
1307         struct nlattr *tb[IPSET_ATTR_ADT_MAX+1] = {};
1308         int ret = 0;
1309
1310         if (unlikely(protocol_failed(attr) ||
1311                      attr[IPSET_ATTR_SETNAME] == NULL ||
1312                      attr[IPSET_ATTR_DATA] == NULL ||
1313                      !flag_nested(attr[IPSET_ATTR_DATA])))
1314                 return -IPSET_ERR_PROTOCOL;
1315
1316         set = find_set(nla_data(attr[IPSET_ATTR_SETNAME]));
1317         if (set == NULL)
1318                 return -ENOENT;
1319
1320         if (nla_parse_nested(tb, IPSET_ATTR_ADT_MAX, attr[IPSET_ATTR_DATA],
1321                              set->type->adt_policy))
1322                 return -IPSET_ERR_PROTOCOL;
1323
1324         read_lock_bh(&set->lock);
1325         ret = set->variant->uadt(set, tb, IPSET_TEST, NULL, 0);
1326         read_unlock_bh(&set->lock);
1327         /* Userspace can't trigger element to be re-added */
1328         if (ret == -EAGAIN)
1329                 ret = 1;
1330
1331         return ret < 0 ? ret : ret > 0 ? 0 : -IPSET_ERR_EXIST;
1332 }
1333
1334 /* Get headed data of a set */
1335
1336 static int
1337 ip_set_header(struct sock *ctnl, struct sk_buff *skb,
1338               const struct nlmsghdr *nlh,
1339               const struct nlattr * const attr[])
1340 {
1341         const struct ip_set *set;
1342         struct sk_buff *skb2;
1343         struct nlmsghdr *nlh2;
1344         ip_set_id_t index;
1345         int ret = 0;
1346
1347         if (unlikely(protocol_failed(attr) ||
1348                      attr[IPSET_ATTR_SETNAME] == NULL))
1349                 return -IPSET_ERR_PROTOCOL;
1350
1351         index = find_set_id(nla_data(attr[IPSET_ATTR_SETNAME]));
1352         if (index == IPSET_INVALID_ID)
1353                 return -ENOENT;
1354         set = ip_set_list[index];
1355
1356         skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1357         if (skb2 == NULL)
1358                 return -ENOMEM;
1359
1360         nlh2 = start_msg(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq, 0,
1361                          IPSET_CMD_HEADER);
1362         if (!nlh2)
1363                 goto nlmsg_failure;
1364         NLA_PUT_U8(skb2, IPSET_ATTR_PROTOCOL, IPSET_PROTOCOL);
1365         NLA_PUT_STRING(skb2, IPSET_ATTR_SETNAME, set->name);
1366         NLA_PUT_STRING(skb2, IPSET_ATTR_TYPENAME, set->type->name);
1367         NLA_PUT_U8(skb2, IPSET_ATTR_FAMILY, set->family);
1368         NLA_PUT_U8(skb2, IPSET_ATTR_REVISION, set->type->revision);
1369         nlmsg_end(skb2, nlh2);
1370
1371         ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1372         if (ret < 0)
1373                 return ret;
1374
1375         return 0;
1376
1377 nla_put_failure:
1378         nlmsg_cancel(skb2, nlh2);
1379 nlmsg_failure:
1380         kfree_skb(skb2);
1381         return -EMSGSIZE;
1382 }
1383
1384 /* Get type data */
1385
1386 static const struct nla_policy ip_set_type_policy[IPSET_ATTR_CMD_MAX + 1] = {
1387         [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
1388         [IPSET_ATTR_TYPENAME]   = { .type = NLA_NUL_STRING,
1389                                     .len = IPSET_MAXNAMELEN - 1 },
1390         [IPSET_ATTR_FAMILY]     = { .type = NLA_U8 },
1391 };
1392
1393 static int
1394 ip_set_type(struct sock *ctnl, struct sk_buff *skb,
1395             const struct nlmsghdr *nlh,
1396             const struct nlattr * const attr[])
1397 {
1398         struct sk_buff *skb2;
1399         struct nlmsghdr *nlh2;
1400         u8 family, min, max;
1401         const char *typename;
1402         int ret = 0;
1403
1404         if (unlikely(protocol_failed(attr) ||
1405                      attr[IPSET_ATTR_TYPENAME] == NULL ||
1406                      attr[IPSET_ATTR_FAMILY] == NULL))
1407                 return -IPSET_ERR_PROTOCOL;
1408
1409         family = nla_get_u8(attr[IPSET_ATTR_FAMILY]);
1410         typename = nla_data(attr[IPSET_ATTR_TYPENAME]);
1411         ret = find_set_type_minmax(typename, family, &min, &max);
1412         if (ret)
1413                 return ret;
1414
1415         skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1416         if (skb2 == NULL)
1417                 return -ENOMEM;
1418
1419         nlh2 = start_msg(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq, 0,
1420                          IPSET_CMD_TYPE);
1421         if (!nlh2)
1422                 goto nlmsg_failure;
1423         NLA_PUT_U8(skb2, IPSET_ATTR_PROTOCOL, IPSET_PROTOCOL);
1424         NLA_PUT_STRING(skb2, IPSET_ATTR_TYPENAME, typename);
1425         NLA_PUT_U8(skb2, IPSET_ATTR_FAMILY, family);
1426         NLA_PUT_U8(skb2, IPSET_ATTR_REVISION, max);
1427         NLA_PUT_U8(skb2, IPSET_ATTR_REVISION_MIN, min);
1428         nlmsg_end(skb2, nlh2);
1429
1430         pr_debug("Send TYPE, nlmsg_len: %u\n", nlh2->nlmsg_len);
1431         ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1432         if (ret < 0)
1433                 return ret;
1434
1435         return 0;
1436
1437 nla_put_failure:
1438         nlmsg_cancel(skb2, nlh2);
1439 nlmsg_failure:
1440         kfree_skb(skb2);
1441         return -EMSGSIZE;
1442 }
1443
1444 /* Get protocol version */
1445
1446 static const struct nla_policy
1447 ip_set_protocol_policy[IPSET_ATTR_CMD_MAX + 1] = {
1448         [IPSET_ATTR_PROTOCOL]   = { .type = NLA_U8 },
1449 };
1450
1451 static int
1452 ip_set_protocol(struct sock *ctnl, struct sk_buff *skb,
1453                 const struct nlmsghdr *nlh,
1454                 const struct nlattr * const attr[])
1455 {
1456         struct sk_buff *skb2;
1457         struct nlmsghdr *nlh2;
1458         int ret = 0;
1459
1460         if (unlikely(attr[IPSET_ATTR_PROTOCOL] == NULL))
1461                 return -IPSET_ERR_PROTOCOL;
1462
1463         skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1464         if (skb2 == NULL)
1465                 return -ENOMEM;
1466
1467         nlh2 = start_msg(skb2, NETLINK_CB(skb).pid, nlh->nlmsg_seq, 0,
1468                          IPSET_CMD_PROTOCOL);
1469         if (!nlh2)
1470                 goto nlmsg_failure;
1471         NLA_PUT_U8(skb2, IPSET_ATTR_PROTOCOL, IPSET_PROTOCOL);
1472         nlmsg_end(skb2, nlh2);
1473
1474         ret = netlink_unicast(ctnl, skb2, NETLINK_CB(skb).pid, MSG_DONTWAIT);
1475         if (ret < 0)
1476                 return ret;
1477
1478         return 0;
1479
1480 nla_put_failure:
1481         nlmsg_cancel(skb2, nlh2);
1482 nlmsg_failure:
1483         kfree_skb(skb2);
1484         return -EMSGSIZE;
1485 }
1486
1487 static const struct nfnl_callback ip_set_netlink_subsys_cb[IPSET_MSG_MAX] = {
1488         [IPSET_CMD_CREATE]      = {
1489                 .call           = ip_set_create,
1490                 .attr_count     = IPSET_ATTR_CMD_MAX,
1491                 .policy         = ip_set_create_policy,
1492         },
1493         [IPSET_CMD_DESTROY]     = {
1494                 .call           = ip_set_destroy,
1495                 .attr_count     = IPSET_ATTR_CMD_MAX,
1496                 .policy         = ip_set_setname_policy,
1497         },
1498         [IPSET_CMD_FLUSH]       = {
1499                 .call           = ip_set_flush,
1500                 .attr_count     = IPSET_ATTR_CMD_MAX,
1501                 .policy         = ip_set_setname_policy,
1502         },
1503         [IPSET_CMD_RENAME]      = {
1504                 .call           = ip_set_rename,
1505                 .attr_count     = IPSET_ATTR_CMD_MAX,
1506                 .policy         = ip_set_setname2_policy,
1507         },
1508         [IPSET_CMD_SWAP]        = {
1509                 .call           = ip_set_swap,
1510                 .attr_count     = IPSET_ATTR_CMD_MAX,
1511                 .policy         = ip_set_setname2_policy,
1512         },
1513         [IPSET_CMD_LIST]        = {
1514                 .call           = ip_set_dump,
1515                 .attr_count     = IPSET_ATTR_CMD_MAX,
1516                 .policy         = ip_set_setname_policy,
1517         },
1518         [IPSET_CMD_SAVE]        = {
1519                 .call           = ip_set_dump,
1520                 .attr_count     = IPSET_ATTR_CMD_MAX,
1521                 .policy         = ip_set_setname_policy,
1522         },
1523         [IPSET_CMD_ADD] = {
1524                 .call           = ip_set_uadd,
1525                 .attr_count     = IPSET_ATTR_CMD_MAX,
1526                 .policy         = ip_set_adt_policy,
1527         },
1528         [IPSET_CMD_DEL] = {
1529                 .call           = ip_set_udel,
1530                 .attr_count     = IPSET_ATTR_CMD_MAX,
1531                 .policy         = ip_set_adt_policy,
1532         },
1533         [IPSET_CMD_TEST]        = {
1534                 .call           = ip_set_utest,
1535                 .attr_count     = IPSET_ATTR_CMD_MAX,
1536                 .policy         = ip_set_adt_policy,
1537         },
1538         [IPSET_CMD_HEADER]      = {
1539                 .call           = ip_set_header,
1540                 .attr_count     = IPSET_ATTR_CMD_MAX,
1541                 .policy         = ip_set_setname_policy,
1542         },
1543         [IPSET_CMD_TYPE]        = {
1544                 .call           = ip_set_type,
1545                 .attr_count     = IPSET_ATTR_CMD_MAX,
1546                 .policy         = ip_set_type_policy,
1547         },
1548         [IPSET_CMD_PROTOCOL]    = {
1549                 .call           = ip_set_protocol,
1550                 .attr_count     = IPSET_ATTR_CMD_MAX,
1551                 .policy         = ip_set_protocol_policy,
1552         },
1553 };
1554
1555 static struct nfnetlink_subsystem ip_set_netlink_subsys __read_mostly = {
1556         .name           = "ip_set",
1557         .subsys_id      = NFNL_SUBSYS_IPSET,
1558         .cb_count       = IPSET_MSG_MAX,
1559         .cb             = ip_set_netlink_subsys_cb,
1560 };
1561
1562 /* Interface to iptables/ip6tables */
1563
1564 static int
1565 ip_set_sockfn_get(struct sock *sk, int optval, void __user *user, int *len)
1566 {
1567         unsigned *op;
1568         void *data;
1569         int copylen = *len, ret = 0;
1570
1571         if (!capable(CAP_NET_ADMIN))
1572                 return -EPERM;
1573         if (optval != SO_IP_SET)
1574                 return -EBADF;
1575         if (*len < sizeof(unsigned))
1576                 return -EINVAL;
1577
1578         data = vmalloc(*len);
1579         if (!data)
1580                 return -ENOMEM;
1581         if (copy_from_user(data, user, *len) != 0) {
1582                 ret = -EFAULT;
1583                 goto done;
1584         }
1585         op = (unsigned *) data;
1586
1587         if (*op < IP_SET_OP_VERSION) {
1588                 /* Check the version at the beginning of operations */
1589                 struct ip_set_req_version *req_version = data;
1590                 if (req_version->version != IPSET_PROTOCOL) {
1591                         ret = -EPROTO;
1592                         goto done;
1593                 }
1594         }
1595
1596         switch (*op) {
1597         case IP_SET_OP_VERSION: {
1598                 struct ip_set_req_version *req_version = data;
1599
1600                 if (*len != sizeof(struct ip_set_req_version)) {
1601                         ret = -EINVAL;
1602                         goto done;
1603                 }
1604
1605                 req_version->version = IPSET_PROTOCOL;
1606                 ret = copy_to_user(user, req_version,
1607                                    sizeof(struct ip_set_req_version));
1608                 goto done;
1609         }
1610         case IP_SET_OP_GET_BYNAME: {
1611                 struct ip_set_req_get_set *req_get = data;
1612
1613                 if (*len != sizeof(struct ip_set_req_get_set)) {
1614                         ret = -EINVAL;
1615                         goto done;
1616                 }
1617                 req_get->set.name[IPSET_MAXNAMELEN - 1] = '\0';
1618                 nfnl_lock();
1619                 req_get->set.index = find_set_id(req_get->set.name);
1620                 nfnl_unlock();
1621                 goto copy;
1622         }
1623         case IP_SET_OP_GET_BYINDEX: {
1624                 struct ip_set_req_get_set *req_get = data;
1625
1626                 if (*len != sizeof(struct ip_set_req_get_set) ||
1627                     req_get->set.index >= ip_set_max) {
1628                         ret = -EINVAL;
1629                         goto done;
1630                 }
1631                 nfnl_lock();
1632                 strncpy(req_get->set.name,
1633                         ip_set_list[req_get->set.index]
1634                                 ? ip_set_list[req_get->set.index]->name : "",
1635                         IPSET_MAXNAMELEN);
1636                 nfnl_unlock();
1637                 goto copy;
1638         }
1639         default:
1640                 ret = -EBADMSG;
1641                 goto done;
1642         }       /* end of switch(op) */
1643
1644 copy:
1645         ret = copy_to_user(user, data, copylen);
1646
1647 done:
1648         vfree(data);
1649         if (ret > 0)
1650                 ret = 0;
1651         return ret;
1652 }
1653
1654 static struct nf_sockopt_ops so_set __read_mostly = {
1655         .pf             = PF_INET,
1656         .get_optmin     = SO_IP_SET,
1657         .get_optmax     = SO_IP_SET + 1,
1658         .get            = &ip_set_sockfn_get,
1659         .owner          = THIS_MODULE,
1660 };
1661
1662 static int __init
1663 ip_set_init(void)
1664 {
1665         int ret;
1666
1667         if (max_sets)
1668                 ip_set_max = max_sets;
1669         if (ip_set_max >= IPSET_INVALID_ID)
1670                 ip_set_max = IPSET_INVALID_ID - 1;
1671
1672         ip_set_list = kzalloc(sizeof(struct ip_set *) * ip_set_max,
1673                               GFP_KERNEL);
1674         if (!ip_set_list) {
1675                 pr_err("ip_set: Unable to create ip_set_list\n");
1676                 return -ENOMEM;
1677         }
1678
1679         ret = nfnetlink_subsys_register(&ip_set_netlink_subsys);
1680         if (ret != 0) {
1681                 pr_err("ip_set: cannot register with nfnetlink.\n");
1682                 kfree(ip_set_list);
1683                 return ret;
1684         }
1685         ret = nf_register_sockopt(&so_set);
1686         if (ret != 0) {
1687                 pr_err("SO_SET registry failed: %d\n", ret);
1688                 nfnetlink_subsys_unregister(&ip_set_netlink_subsys);
1689                 kfree(ip_set_list);
1690                 return ret;
1691         }
1692
1693         pr_notice("ip_set: protocol %u\n", IPSET_PROTOCOL);
1694         return 0;
1695 }
1696
1697 static void __exit
1698 ip_set_fini(void)
1699 {
1700         /* There can't be any existing set */
1701         nf_unregister_sockopt(&so_set);
1702         nfnetlink_subsys_unregister(&ip_set_netlink_subsys);
1703         kfree(ip_set_list);
1704         pr_debug("these are the famous last words\n");
1705 }
1706
1707 module_init(ip_set_init);
1708 module_exit(ip_set_fini);