d83c0d01a26628ffb0d1d1cf80e245db7162ced6
[muen/linux.git] / net / netfilter / nf_tables_api.c
1 /*
2  * Copyright (c) 2007-2009 Patrick McHardy <kaber@trash.net>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  *
8  * Development of this code funded by Astaro AG (http://www.astaro.com/)
9  */
10
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/list.h>
14 #include <linux/skbuff.h>
15 #include <linux/netlink.h>
16 #include <linux/vmalloc.h>
17 #include <linux/rhashtable.h>
18 #include <linux/netfilter.h>
19 #include <linux/netfilter/nfnetlink.h>
20 #include <linux/netfilter/nf_tables.h>
21 #include <net/netfilter/nf_flow_table.h>
22 #include <net/netfilter/nf_tables_core.h>
23 #include <net/netfilter/nf_tables.h>
24 #include <net/net_namespace.h>
25 #include <net/sock.h>
26
27 static LIST_HEAD(nf_tables_expressions);
28 static LIST_HEAD(nf_tables_objects);
29 static LIST_HEAD(nf_tables_flowtables);
30 static u64 table_handle;
31
32 enum {
33         NFT_VALIDATE_SKIP       = 0,
34         NFT_VALIDATE_NEED,
35         NFT_VALIDATE_DO,
36 };
37
38 static u32 nft_chain_hash(const void *data, u32 len, u32 seed);
39 static u32 nft_chain_hash_obj(const void *data, u32 len, u32 seed);
40 static int nft_chain_hash_cmp(struct rhashtable_compare_arg *, const void *);
41
42 static const struct rhashtable_params nft_chain_ht_params = {
43         .head_offset            = offsetof(struct nft_chain, rhlhead),
44         .key_offset             = offsetof(struct nft_chain, name),
45         .hashfn                 = nft_chain_hash,
46         .obj_hashfn             = nft_chain_hash_obj,
47         .obj_cmpfn              = nft_chain_hash_cmp,
48         .locks_mul              = 1,
49         .automatic_shrinking    = true,
50 };
51
52 static void nft_validate_state_update(struct net *net, u8 new_validate_state)
53 {
54         switch (net->nft.validate_state) {
55         case NFT_VALIDATE_SKIP:
56                 WARN_ON_ONCE(new_validate_state == NFT_VALIDATE_DO);
57                 break;
58         case NFT_VALIDATE_NEED:
59                 break;
60         case NFT_VALIDATE_DO:
61                 if (new_validate_state == NFT_VALIDATE_NEED)
62                         return;
63         }
64
65         net->nft.validate_state = new_validate_state;
66 }
67
68 static void nft_ctx_init(struct nft_ctx *ctx,
69                          struct net *net,
70                          const struct sk_buff *skb,
71                          const struct nlmsghdr *nlh,
72                          u8 family,
73                          struct nft_table *table,
74                          struct nft_chain *chain,
75                          const struct nlattr * const *nla)
76 {
77         ctx->net        = net;
78         ctx->family     = family;
79         ctx->level      = 0;
80         ctx->table      = table;
81         ctx->chain      = chain;
82         ctx->nla        = nla;
83         ctx->portid     = NETLINK_CB(skb).portid;
84         ctx->report     = nlmsg_report(nlh);
85         ctx->seq        = nlh->nlmsg_seq;
86 }
87
88 static struct nft_trans *nft_trans_alloc_gfp(const struct nft_ctx *ctx,
89                                              int msg_type, u32 size, gfp_t gfp)
90 {
91         struct nft_trans *trans;
92
93         trans = kzalloc(sizeof(struct nft_trans) + size, gfp);
94         if (trans == NULL)
95                 return NULL;
96
97         trans->msg_type = msg_type;
98         trans->ctx      = *ctx;
99
100         return trans;
101 }
102
103 static struct nft_trans *nft_trans_alloc(const struct nft_ctx *ctx,
104                                          int msg_type, u32 size)
105 {
106         return nft_trans_alloc_gfp(ctx, msg_type, size, GFP_KERNEL);
107 }
108
109 static void nft_trans_destroy(struct nft_trans *trans)
110 {
111         list_del(&trans->list);
112         kfree(trans);
113 }
114
115 static int nf_tables_register_hook(struct net *net,
116                                    const struct nft_table *table,
117                                    struct nft_chain *chain)
118 {
119         const struct nft_base_chain *basechain;
120         const struct nf_hook_ops *ops;
121
122         if (table->flags & NFT_TABLE_F_DORMANT ||
123             !nft_is_base_chain(chain))
124                 return 0;
125
126         basechain = nft_base_chain(chain);
127         ops = &basechain->ops;
128
129         if (basechain->type->ops_register)
130                 return basechain->type->ops_register(net, ops);
131
132         return nf_register_net_hook(net, ops);
133 }
134
135 static void nf_tables_unregister_hook(struct net *net,
136                                       const struct nft_table *table,
137                                       struct nft_chain *chain)
138 {
139         const struct nft_base_chain *basechain;
140         const struct nf_hook_ops *ops;
141
142         if (table->flags & NFT_TABLE_F_DORMANT ||
143             !nft_is_base_chain(chain))
144                 return;
145         basechain = nft_base_chain(chain);
146         ops = &basechain->ops;
147
148         if (basechain->type->ops_unregister)
149                 return basechain->type->ops_unregister(net, ops);
150
151         nf_unregister_net_hook(net, ops);
152 }
153
154 static int nft_trans_table_add(struct nft_ctx *ctx, int msg_type)
155 {
156         struct nft_trans *trans;
157
158         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_table));
159         if (trans == NULL)
160                 return -ENOMEM;
161
162         if (msg_type == NFT_MSG_NEWTABLE)
163                 nft_activate_next(ctx->net, ctx->table);
164
165         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
166         return 0;
167 }
168
169 static int nft_deltable(struct nft_ctx *ctx)
170 {
171         int err;
172
173         err = nft_trans_table_add(ctx, NFT_MSG_DELTABLE);
174         if (err < 0)
175                 return err;
176
177         nft_deactivate_next(ctx->net, ctx->table);
178         return err;
179 }
180
181 static int nft_trans_chain_add(struct nft_ctx *ctx, int msg_type)
182 {
183         struct nft_trans *trans;
184
185         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_chain));
186         if (trans == NULL)
187                 return -ENOMEM;
188
189         if (msg_type == NFT_MSG_NEWCHAIN)
190                 nft_activate_next(ctx->net, ctx->chain);
191
192         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
193         return 0;
194 }
195
196 static int nft_delchain(struct nft_ctx *ctx)
197 {
198         int err;
199
200         err = nft_trans_chain_add(ctx, NFT_MSG_DELCHAIN);
201         if (err < 0)
202                 return err;
203
204         ctx->table->use--;
205         nft_deactivate_next(ctx->net, ctx->chain);
206
207         return err;
208 }
209
210 static void nft_rule_expr_activate(const struct nft_ctx *ctx,
211                                    struct nft_rule *rule)
212 {
213         struct nft_expr *expr;
214
215         expr = nft_expr_first(rule);
216         while (expr != nft_expr_last(rule) && expr->ops) {
217                 if (expr->ops->activate)
218                         expr->ops->activate(ctx, expr);
219
220                 expr = nft_expr_next(expr);
221         }
222 }
223
224 static void nft_rule_expr_deactivate(const struct nft_ctx *ctx,
225                                      struct nft_rule *rule)
226 {
227         struct nft_expr *expr;
228
229         expr = nft_expr_first(rule);
230         while (expr != nft_expr_last(rule) && expr->ops) {
231                 if (expr->ops->deactivate)
232                         expr->ops->deactivate(ctx, expr);
233
234                 expr = nft_expr_next(expr);
235         }
236 }
237
238 static int
239 nf_tables_delrule_deactivate(struct nft_ctx *ctx, struct nft_rule *rule)
240 {
241         /* You cannot delete the same rule twice */
242         if (nft_is_active_next(ctx->net, rule)) {
243                 nft_deactivate_next(ctx->net, rule);
244                 ctx->chain->use--;
245                 return 0;
246         }
247         return -ENOENT;
248 }
249
250 static struct nft_trans *nft_trans_rule_add(struct nft_ctx *ctx, int msg_type,
251                                             struct nft_rule *rule)
252 {
253         struct nft_trans *trans;
254
255         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_rule));
256         if (trans == NULL)
257                 return NULL;
258
259         if (msg_type == NFT_MSG_NEWRULE && ctx->nla[NFTA_RULE_ID] != NULL) {
260                 nft_trans_rule_id(trans) =
261                         ntohl(nla_get_be32(ctx->nla[NFTA_RULE_ID]));
262         }
263         nft_trans_rule(trans) = rule;
264         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
265
266         return trans;
267 }
268
269 static int nft_delrule(struct nft_ctx *ctx, struct nft_rule *rule)
270 {
271         struct nft_trans *trans;
272         int err;
273
274         trans = nft_trans_rule_add(ctx, NFT_MSG_DELRULE, rule);
275         if (trans == NULL)
276                 return -ENOMEM;
277
278         err = nf_tables_delrule_deactivate(ctx, rule);
279         if (err < 0) {
280                 nft_trans_destroy(trans);
281                 return err;
282         }
283         nft_rule_expr_deactivate(ctx, rule);
284
285         return 0;
286 }
287
288 static int nft_delrule_by_chain(struct nft_ctx *ctx)
289 {
290         struct nft_rule *rule;
291         int err;
292
293         list_for_each_entry(rule, &ctx->chain->rules, list) {
294                 err = nft_delrule(ctx, rule);
295                 if (err < 0)
296                         return err;
297         }
298         return 0;
299 }
300
301 static int nft_trans_set_add(struct nft_ctx *ctx, int msg_type,
302                              struct nft_set *set)
303 {
304         struct nft_trans *trans;
305
306         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_set));
307         if (trans == NULL)
308                 return -ENOMEM;
309
310         if (msg_type == NFT_MSG_NEWSET && ctx->nla[NFTA_SET_ID] != NULL) {
311                 nft_trans_set_id(trans) =
312                         ntohl(nla_get_be32(ctx->nla[NFTA_SET_ID]));
313                 nft_activate_next(ctx->net, set);
314         }
315         nft_trans_set(trans) = set;
316         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
317
318         return 0;
319 }
320
321 static int nft_delset(struct nft_ctx *ctx, struct nft_set *set)
322 {
323         int err;
324
325         err = nft_trans_set_add(ctx, NFT_MSG_DELSET, set);
326         if (err < 0)
327                 return err;
328
329         nft_deactivate_next(ctx->net, set);
330         ctx->table->use--;
331
332         return err;
333 }
334
335 static int nft_trans_obj_add(struct nft_ctx *ctx, int msg_type,
336                              struct nft_object *obj)
337 {
338         struct nft_trans *trans;
339
340         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_obj));
341         if (trans == NULL)
342                 return -ENOMEM;
343
344         if (msg_type == NFT_MSG_NEWOBJ)
345                 nft_activate_next(ctx->net, obj);
346
347         nft_trans_obj(trans) = obj;
348         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
349
350         return 0;
351 }
352
353 static int nft_delobj(struct nft_ctx *ctx, struct nft_object *obj)
354 {
355         int err;
356
357         err = nft_trans_obj_add(ctx, NFT_MSG_DELOBJ, obj);
358         if (err < 0)
359                 return err;
360
361         nft_deactivate_next(ctx->net, obj);
362         ctx->table->use--;
363
364         return err;
365 }
366
367 static int nft_trans_flowtable_add(struct nft_ctx *ctx, int msg_type,
368                                    struct nft_flowtable *flowtable)
369 {
370         struct nft_trans *trans;
371
372         trans = nft_trans_alloc(ctx, msg_type,
373                                 sizeof(struct nft_trans_flowtable));
374         if (trans == NULL)
375                 return -ENOMEM;
376
377         if (msg_type == NFT_MSG_NEWFLOWTABLE)
378                 nft_activate_next(ctx->net, flowtable);
379
380         nft_trans_flowtable(trans) = flowtable;
381         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
382
383         return 0;
384 }
385
386 static int nft_delflowtable(struct nft_ctx *ctx,
387                             struct nft_flowtable *flowtable)
388 {
389         int err;
390
391         err = nft_trans_flowtable_add(ctx, NFT_MSG_DELFLOWTABLE, flowtable);
392         if (err < 0)
393                 return err;
394
395         nft_deactivate_next(ctx->net, flowtable);
396         ctx->table->use--;
397
398         return err;
399 }
400
401 /*
402  * Tables
403  */
404
405 static struct nft_table *nft_table_lookup(const struct net *net,
406                                           const struct nlattr *nla,
407                                           u8 family, u8 genmask)
408 {
409         struct nft_table *table;
410
411         if (nla == NULL)
412                 return ERR_PTR(-EINVAL);
413
414         list_for_each_entry_rcu(table, &net->nft.tables, list) {
415                 if (!nla_strcmp(nla, table->name) &&
416                     table->family == family &&
417                     nft_active_genmask(table, genmask))
418                         return table;
419         }
420
421         return ERR_PTR(-ENOENT);
422 }
423
424 static struct nft_table *nft_table_lookup_byhandle(const struct net *net,
425                                                    const struct nlattr *nla,
426                                                    u8 genmask)
427 {
428         struct nft_table *table;
429
430         list_for_each_entry(table, &net->nft.tables, list) {
431                 if (be64_to_cpu(nla_get_be64(nla)) == table->handle &&
432                     nft_active_genmask(table, genmask))
433                         return table;
434         }
435
436         return ERR_PTR(-ENOENT);
437 }
438
439 static inline u64 nf_tables_alloc_handle(struct nft_table *table)
440 {
441         return ++table->hgenerator;
442 }
443
444 static const struct nft_chain_type *chain_type[NFPROTO_NUMPROTO][NFT_CHAIN_T_MAX];
445
446 static const struct nft_chain_type *
447 __nf_tables_chain_type_lookup(const struct nlattr *nla, u8 family)
448 {
449         int i;
450
451         for (i = 0; i < NFT_CHAIN_T_MAX; i++) {
452                 if (chain_type[family][i] != NULL &&
453                     !nla_strcmp(nla, chain_type[family][i]->name))
454                         return chain_type[family][i];
455         }
456         return NULL;
457 }
458
459 /*
460  * Loading a module requires dropping mutex that guards the
461  * transaction.
462  * We first need to abort any pending transactions as once
463  * mutex is unlocked a different client could start a new
464  * transaction.  It must not see any 'future generation'
465  * changes * as these changes will never happen.
466  */
467 #ifdef CONFIG_MODULES
468 static int __nf_tables_abort(struct net *net);
469
470 static void nft_request_module(struct net *net, const char *fmt, ...)
471 {
472         char module_name[MODULE_NAME_LEN];
473         va_list args;
474         int ret;
475
476         __nf_tables_abort(net);
477
478         va_start(args, fmt);
479         ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);
480         va_end(args);
481         if (WARN(ret >= MODULE_NAME_LEN, "truncated: '%s' (len %d)", module_name, ret))
482                 return;
483
484         mutex_unlock(&net->nft.commit_mutex);
485         request_module("%s", module_name);
486         mutex_lock(&net->nft.commit_mutex);
487 }
488 #endif
489
490 static void lockdep_nfnl_nft_mutex_not_held(void)
491 {
492 #ifdef CONFIG_PROVE_LOCKING
493         WARN_ON_ONCE(lockdep_nfnl_is_held(NFNL_SUBSYS_NFTABLES));
494 #endif
495 }
496
497 static const struct nft_chain_type *
498 nf_tables_chain_type_lookup(struct net *net, const struct nlattr *nla,
499                             u8 family, bool autoload)
500 {
501         const struct nft_chain_type *type;
502
503         type = __nf_tables_chain_type_lookup(nla, family);
504         if (type != NULL)
505                 return type;
506
507         lockdep_nfnl_nft_mutex_not_held();
508 #ifdef CONFIG_MODULES
509         if (autoload) {
510                 nft_request_module(net, "nft-chain-%u-%.*s", family,
511                                    nla_len(nla), (const char *)nla_data(nla));
512                 type = __nf_tables_chain_type_lookup(nla, family);
513                 if (type != NULL)
514                         return ERR_PTR(-EAGAIN);
515         }
516 #endif
517         return ERR_PTR(-ENOENT);
518 }
519
520 static const struct nla_policy nft_table_policy[NFTA_TABLE_MAX + 1] = {
521         [NFTA_TABLE_NAME]       = { .type = NLA_STRING,
522                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
523         [NFTA_TABLE_FLAGS]      = { .type = NLA_U32 },
524         [NFTA_TABLE_HANDLE]     = { .type = NLA_U64 },
525 };
526
527 static int nf_tables_fill_table_info(struct sk_buff *skb, struct net *net,
528                                      u32 portid, u32 seq, int event, u32 flags,
529                                      int family, const struct nft_table *table)
530 {
531         struct nlmsghdr *nlh;
532         struct nfgenmsg *nfmsg;
533
534         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
535         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags);
536         if (nlh == NULL)
537                 goto nla_put_failure;
538
539         nfmsg = nlmsg_data(nlh);
540         nfmsg->nfgen_family     = family;
541         nfmsg->version          = NFNETLINK_V0;
542         nfmsg->res_id           = htons(net->nft.base_seq & 0xffff);
543
544         if (nla_put_string(skb, NFTA_TABLE_NAME, table->name) ||
545             nla_put_be32(skb, NFTA_TABLE_FLAGS, htonl(table->flags)) ||
546             nla_put_be32(skb, NFTA_TABLE_USE, htonl(table->use)) ||
547             nla_put_be64(skb, NFTA_TABLE_HANDLE, cpu_to_be64(table->handle),
548                          NFTA_TABLE_PAD))
549                 goto nla_put_failure;
550
551         nlmsg_end(skb, nlh);
552         return 0;
553
554 nla_put_failure:
555         nlmsg_trim(skb, nlh);
556         return -1;
557 }
558
559 static void nf_tables_table_notify(const struct nft_ctx *ctx, int event)
560 {
561         struct sk_buff *skb;
562         int err;
563
564         if (!ctx->report &&
565             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
566                 return;
567
568         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
569         if (skb == NULL)
570                 goto err;
571
572         err = nf_tables_fill_table_info(skb, ctx->net, ctx->portid, ctx->seq,
573                                         event, 0, ctx->family, ctx->table);
574         if (err < 0) {
575                 kfree_skb(skb);
576                 goto err;
577         }
578
579         nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
580                        ctx->report, GFP_KERNEL);
581         return;
582 err:
583         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
584 }
585
586 static int nf_tables_dump_tables(struct sk_buff *skb,
587                                  struct netlink_callback *cb)
588 {
589         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
590         const struct nft_table *table;
591         unsigned int idx = 0, s_idx = cb->args[0];
592         struct net *net = sock_net(skb->sk);
593         int family = nfmsg->nfgen_family;
594
595         rcu_read_lock();
596         cb->seq = net->nft.base_seq;
597
598         list_for_each_entry_rcu(table, &net->nft.tables, list) {
599                 if (family != NFPROTO_UNSPEC && family != table->family)
600                         continue;
601
602                 if (idx < s_idx)
603                         goto cont;
604                 if (idx > s_idx)
605                         memset(&cb->args[1], 0,
606                                sizeof(cb->args) - sizeof(cb->args[0]));
607                 if (!nft_is_active(net, table))
608                         continue;
609                 if (nf_tables_fill_table_info(skb, net,
610                                               NETLINK_CB(cb->skb).portid,
611                                               cb->nlh->nlmsg_seq,
612                                               NFT_MSG_NEWTABLE, NLM_F_MULTI,
613                                               table->family, table) < 0)
614                         goto done;
615
616                 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
617 cont:
618                 idx++;
619         }
620 done:
621         rcu_read_unlock();
622         cb->args[0] = idx;
623         return skb->len;
624 }
625
626 static int nft_netlink_dump_start_rcu(struct sock *nlsk, struct sk_buff *skb,
627                                       const struct nlmsghdr *nlh,
628                                       struct netlink_dump_control *c)
629 {
630         int err;
631
632         if (!try_module_get(THIS_MODULE))
633                 return -EINVAL;
634
635         rcu_read_unlock();
636         err = netlink_dump_start(nlsk, skb, nlh, c);
637         rcu_read_lock();
638         module_put(THIS_MODULE);
639
640         return err;
641 }
642
643 /* called with rcu_read_lock held */
644 static int nf_tables_gettable(struct net *net, struct sock *nlsk,
645                               struct sk_buff *skb, const struct nlmsghdr *nlh,
646                               const struct nlattr * const nla[],
647                               struct netlink_ext_ack *extack)
648 {
649         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
650         u8 genmask = nft_genmask_cur(net);
651         const struct nft_table *table;
652         struct sk_buff *skb2;
653         int family = nfmsg->nfgen_family;
654         int err;
655
656         if (nlh->nlmsg_flags & NLM_F_DUMP) {
657                 struct netlink_dump_control c = {
658                         .dump = nf_tables_dump_tables,
659                         .module = THIS_MODULE,
660                 };
661
662                 return nft_netlink_dump_start_rcu(nlsk, skb, nlh, &c);
663         }
664
665         table = nft_table_lookup(net, nla[NFTA_TABLE_NAME], family, genmask);
666         if (IS_ERR(table)) {
667                 NL_SET_BAD_ATTR(extack, nla[NFTA_TABLE_NAME]);
668                 return PTR_ERR(table);
669         }
670
671         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
672         if (!skb2)
673                 return -ENOMEM;
674
675         err = nf_tables_fill_table_info(skb2, net, NETLINK_CB(skb).portid,
676                                         nlh->nlmsg_seq, NFT_MSG_NEWTABLE, 0,
677                                         family, table);
678         if (err < 0)
679                 goto err;
680
681         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
682
683 err:
684         kfree_skb(skb2);
685         return err;
686 }
687
688 static void nft_table_disable(struct net *net, struct nft_table *table, u32 cnt)
689 {
690         struct nft_chain *chain;
691         u32 i = 0;
692
693         list_for_each_entry(chain, &table->chains, list) {
694                 if (!nft_is_active_next(net, chain))
695                         continue;
696                 if (!nft_is_base_chain(chain))
697                         continue;
698
699                 if (cnt && i++ == cnt)
700                         break;
701
702                 nf_unregister_net_hook(net, &nft_base_chain(chain)->ops);
703         }
704 }
705
706 static int nf_tables_table_enable(struct net *net, struct nft_table *table)
707 {
708         struct nft_chain *chain;
709         int err, i = 0;
710
711         list_for_each_entry(chain, &table->chains, list) {
712                 if (!nft_is_active_next(net, chain))
713                         continue;
714                 if (!nft_is_base_chain(chain))
715                         continue;
716
717                 err = nf_register_net_hook(net, &nft_base_chain(chain)->ops);
718                 if (err < 0)
719                         goto err;
720
721                 i++;
722         }
723         return 0;
724 err:
725         if (i)
726                 nft_table_disable(net, table, i);
727         return err;
728 }
729
730 static void nf_tables_table_disable(struct net *net, struct nft_table *table)
731 {
732         nft_table_disable(net, table, 0);
733 }
734
735 static int nf_tables_updtable(struct nft_ctx *ctx)
736 {
737         struct nft_trans *trans;
738         u32 flags;
739         int ret = 0;
740
741         if (!ctx->nla[NFTA_TABLE_FLAGS])
742                 return 0;
743
744         flags = ntohl(nla_get_be32(ctx->nla[NFTA_TABLE_FLAGS]));
745         if (flags & ~NFT_TABLE_F_DORMANT)
746                 return -EINVAL;
747
748         if (flags == ctx->table->flags)
749                 return 0;
750
751         trans = nft_trans_alloc(ctx, NFT_MSG_NEWTABLE,
752                                 sizeof(struct nft_trans_table));
753         if (trans == NULL)
754                 return -ENOMEM;
755
756         if ((flags & NFT_TABLE_F_DORMANT) &&
757             !(ctx->table->flags & NFT_TABLE_F_DORMANT)) {
758                 nft_trans_table_enable(trans) = false;
759         } else if (!(flags & NFT_TABLE_F_DORMANT) &&
760                    ctx->table->flags & NFT_TABLE_F_DORMANT) {
761                 ret = nf_tables_table_enable(ctx->net, ctx->table);
762                 if (ret >= 0) {
763                         ctx->table->flags &= ~NFT_TABLE_F_DORMANT;
764                         nft_trans_table_enable(trans) = true;
765                 }
766         }
767         if (ret < 0)
768                 goto err;
769
770         nft_trans_table_update(trans) = true;
771         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
772         return 0;
773 err:
774         nft_trans_destroy(trans);
775         return ret;
776 }
777
778 static u32 nft_chain_hash(const void *data, u32 len, u32 seed)
779 {
780         const char *name = data;
781
782         return jhash(name, strlen(name), seed);
783 }
784
785 static u32 nft_chain_hash_obj(const void *data, u32 len, u32 seed)
786 {
787         const struct nft_chain *chain = data;
788
789         return nft_chain_hash(chain->name, 0, seed);
790 }
791
792 static int nft_chain_hash_cmp(struct rhashtable_compare_arg *arg,
793                               const void *ptr)
794 {
795         const struct nft_chain *chain = ptr;
796         const char *name = arg->key;
797
798         return strcmp(chain->name, name);
799 }
800
801 static int nf_tables_newtable(struct net *net, struct sock *nlsk,
802                               struct sk_buff *skb, const struct nlmsghdr *nlh,
803                               const struct nlattr * const nla[],
804                               struct netlink_ext_ack *extack)
805 {
806         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
807         u8 genmask = nft_genmask_next(net);
808         int family = nfmsg->nfgen_family;
809         const struct nlattr *attr;
810         struct nft_table *table;
811         u32 flags = 0;
812         struct nft_ctx ctx;
813         int err;
814
815         lockdep_assert_held(&net->nft.commit_mutex);
816         attr = nla[NFTA_TABLE_NAME];
817         table = nft_table_lookup(net, attr, family, genmask);
818         if (IS_ERR(table)) {
819                 if (PTR_ERR(table) != -ENOENT)
820                         return PTR_ERR(table);
821         } else {
822                 if (nlh->nlmsg_flags & NLM_F_EXCL) {
823                         NL_SET_BAD_ATTR(extack, attr);
824                         return -EEXIST;
825                 }
826                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
827                         return -EOPNOTSUPP;
828
829                 nft_ctx_init(&ctx, net, skb, nlh, family, table, NULL, nla);
830                 return nf_tables_updtable(&ctx);
831         }
832
833         if (nla[NFTA_TABLE_FLAGS]) {
834                 flags = ntohl(nla_get_be32(nla[NFTA_TABLE_FLAGS]));
835                 if (flags & ~NFT_TABLE_F_DORMANT)
836                         return -EINVAL;
837         }
838
839         err = -ENOMEM;
840         table = kzalloc(sizeof(*table), GFP_KERNEL);
841         if (table == NULL)
842                 goto err_kzalloc;
843
844         table->name = nla_strdup(attr, GFP_KERNEL);
845         if (table->name == NULL)
846                 goto err_strdup;
847
848         err = rhltable_init(&table->chains_ht, &nft_chain_ht_params);
849         if (err)
850                 goto err_chain_ht;
851
852         INIT_LIST_HEAD(&table->chains);
853         INIT_LIST_HEAD(&table->sets);
854         INIT_LIST_HEAD(&table->objects);
855         INIT_LIST_HEAD(&table->flowtables);
856         table->family = family;
857         table->flags = flags;
858         table->handle = ++table_handle;
859
860         nft_ctx_init(&ctx, net, skb, nlh, family, table, NULL, nla);
861         err = nft_trans_table_add(&ctx, NFT_MSG_NEWTABLE);
862         if (err < 0)
863                 goto err_trans;
864
865         list_add_tail_rcu(&table->list, &net->nft.tables);
866         return 0;
867 err_trans:
868         rhltable_destroy(&table->chains_ht);
869 err_chain_ht:
870         kfree(table->name);
871 err_strdup:
872         kfree(table);
873 err_kzalloc:
874         return err;
875 }
876
877 static int nft_flush_table(struct nft_ctx *ctx)
878 {
879         struct nft_flowtable *flowtable, *nft;
880         struct nft_chain *chain, *nc;
881         struct nft_object *obj, *ne;
882         struct nft_set *set, *ns;
883         int err;
884
885         list_for_each_entry(chain, &ctx->table->chains, list) {
886                 if (!nft_is_active_next(ctx->net, chain))
887                         continue;
888
889                 ctx->chain = chain;
890
891                 err = nft_delrule_by_chain(ctx);
892                 if (err < 0)
893                         goto out;
894         }
895
896         list_for_each_entry_safe(set, ns, &ctx->table->sets, list) {
897                 if (!nft_is_active_next(ctx->net, set))
898                         continue;
899
900                 if (nft_set_is_anonymous(set) &&
901                     !list_empty(&set->bindings))
902                         continue;
903
904                 err = nft_delset(ctx, set);
905                 if (err < 0)
906                         goto out;
907         }
908
909         list_for_each_entry_safe(flowtable, nft, &ctx->table->flowtables, list) {
910                 err = nft_delflowtable(ctx, flowtable);
911                 if (err < 0)
912                         goto out;
913         }
914
915         list_for_each_entry_safe(obj, ne, &ctx->table->objects, list) {
916                 err = nft_delobj(ctx, obj);
917                 if (err < 0)
918                         goto out;
919         }
920
921         list_for_each_entry_safe(chain, nc, &ctx->table->chains, list) {
922                 if (!nft_is_active_next(ctx->net, chain))
923                         continue;
924
925                 ctx->chain = chain;
926
927                 err = nft_delchain(ctx);
928                 if (err < 0)
929                         goto out;
930         }
931
932         err = nft_deltable(ctx);
933 out:
934         return err;
935 }
936
937 static int nft_flush(struct nft_ctx *ctx, int family)
938 {
939         struct nft_table *table, *nt;
940         const struct nlattr * const *nla = ctx->nla;
941         int err = 0;
942
943         list_for_each_entry_safe(table, nt, &ctx->net->nft.tables, list) {
944                 if (family != AF_UNSPEC && table->family != family)
945                         continue;
946
947                 ctx->family = table->family;
948
949                 if (!nft_is_active_next(ctx->net, table))
950                         continue;
951
952                 if (nla[NFTA_TABLE_NAME] &&
953                     nla_strcmp(nla[NFTA_TABLE_NAME], table->name) != 0)
954                         continue;
955
956                 ctx->table = table;
957
958                 err = nft_flush_table(ctx);
959                 if (err < 0)
960                         goto out;
961         }
962 out:
963         return err;
964 }
965
966 static int nf_tables_deltable(struct net *net, struct sock *nlsk,
967                               struct sk_buff *skb, const struct nlmsghdr *nlh,
968                               const struct nlattr * const nla[],
969                               struct netlink_ext_ack *extack)
970 {
971         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
972         u8 genmask = nft_genmask_next(net);
973         int family = nfmsg->nfgen_family;
974         const struct nlattr *attr;
975         struct nft_table *table;
976         struct nft_ctx ctx;
977
978         nft_ctx_init(&ctx, net, skb, nlh, 0, NULL, NULL, nla);
979         if (family == AF_UNSPEC ||
980             (!nla[NFTA_TABLE_NAME] && !nla[NFTA_TABLE_HANDLE]))
981                 return nft_flush(&ctx, family);
982
983         if (nla[NFTA_TABLE_HANDLE]) {
984                 attr = nla[NFTA_TABLE_HANDLE];
985                 table = nft_table_lookup_byhandle(net, attr, genmask);
986         } else {
987                 attr = nla[NFTA_TABLE_NAME];
988                 table = nft_table_lookup(net, attr, family, genmask);
989         }
990
991         if (IS_ERR(table)) {
992                 NL_SET_BAD_ATTR(extack, attr);
993                 return PTR_ERR(table);
994         }
995
996         if (nlh->nlmsg_flags & NLM_F_NONREC &&
997             table->use > 0)
998                 return -EBUSY;
999
1000         ctx.family = family;
1001         ctx.table = table;
1002
1003         return nft_flush_table(&ctx);
1004 }
1005
1006 static void nf_tables_table_destroy(struct nft_ctx *ctx)
1007 {
1008         BUG_ON(ctx->table->use > 0);
1009
1010         rhltable_destroy(&ctx->table->chains_ht);
1011         kfree(ctx->table->name);
1012         kfree(ctx->table);
1013 }
1014
1015 void nft_register_chain_type(const struct nft_chain_type *ctype)
1016 {
1017         if (WARN_ON(ctype->family >= NFPROTO_NUMPROTO))
1018                 return;
1019
1020         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1021         if (WARN_ON(chain_type[ctype->family][ctype->type] != NULL)) {
1022                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1023                 return;
1024         }
1025         chain_type[ctype->family][ctype->type] = ctype;
1026         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1027 }
1028 EXPORT_SYMBOL_GPL(nft_register_chain_type);
1029
1030 void nft_unregister_chain_type(const struct nft_chain_type *ctype)
1031 {
1032         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1033         chain_type[ctype->family][ctype->type] = NULL;
1034         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1035 }
1036 EXPORT_SYMBOL_GPL(nft_unregister_chain_type);
1037
1038 /*
1039  * Chains
1040  */
1041
1042 static struct nft_chain *
1043 nft_chain_lookup_byhandle(const struct nft_table *table, u64 handle, u8 genmask)
1044 {
1045         struct nft_chain *chain;
1046
1047         list_for_each_entry(chain, &table->chains, list) {
1048                 if (chain->handle == handle &&
1049                     nft_active_genmask(chain, genmask))
1050                         return chain;
1051         }
1052
1053         return ERR_PTR(-ENOENT);
1054 }
1055
1056 static bool lockdep_commit_lock_is_held(struct net *net)
1057 {
1058 #ifdef CONFIG_PROVE_LOCKING
1059         return lockdep_is_held(&net->nft.commit_mutex);
1060 #else
1061         return true;
1062 #endif
1063 }
1064
1065 static struct nft_chain *nft_chain_lookup(struct net *net,
1066                                           struct nft_table *table,
1067                                           const struct nlattr *nla, u8 genmask)
1068 {
1069         char search[NFT_CHAIN_MAXNAMELEN + 1];
1070         struct rhlist_head *tmp, *list;
1071         struct nft_chain *chain;
1072
1073         if (nla == NULL)
1074                 return ERR_PTR(-EINVAL);
1075
1076         nla_strlcpy(search, nla, sizeof(search));
1077
1078         WARN_ON(!rcu_read_lock_held() &&
1079                 !lockdep_commit_lock_is_held(net));
1080
1081         chain = ERR_PTR(-ENOENT);
1082         rcu_read_lock();
1083         list = rhltable_lookup(&table->chains_ht, search, nft_chain_ht_params);
1084         if (!list)
1085                 goto out_unlock;
1086
1087         rhl_for_each_entry_rcu(chain, tmp, list, rhlhead) {
1088                 if (nft_active_genmask(chain, genmask))
1089                         goto out_unlock;
1090         }
1091         chain = ERR_PTR(-ENOENT);
1092 out_unlock:
1093         rcu_read_unlock();
1094         return chain;
1095 }
1096
1097 static const struct nla_policy nft_chain_policy[NFTA_CHAIN_MAX + 1] = {
1098         [NFTA_CHAIN_TABLE]      = { .type = NLA_STRING,
1099                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
1100         [NFTA_CHAIN_HANDLE]     = { .type = NLA_U64 },
1101         [NFTA_CHAIN_NAME]       = { .type = NLA_STRING,
1102                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
1103         [NFTA_CHAIN_HOOK]       = { .type = NLA_NESTED },
1104         [NFTA_CHAIN_POLICY]     = { .type = NLA_U32 },
1105         [NFTA_CHAIN_TYPE]       = { .type = NLA_STRING },
1106         [NFTA_CHAIN_COUNTERS]   = { .type = NLA_NESTED },
1107 };
1108
1109 static const struct nla_policy nft_hook_policy[NFTA_HOOK_MAX + 1] = {
1110         [NFTA_HOOK_HOOKNUM]     = { .type = NLA_U32 },
1111         [NFTA_HOOK_PRIORITY]    = { .type = NLA_U32 },
1112         [NFTA_HOOK_DEV]         = { .type = NLA_STRING,
1113                                     .len = IFNAMSIZ - 1 },
1114 };
1115
1116 static int nft_dump_stats(struct sk_buff *skb, struct nft_stats __percpu *stats)
1117 {
1118         struct nft_stats *cpu_stats, total;
1119         struct nlattr *nest;
1120         unsigned int seq;
1121         u64 pkts, bytes;
1122         int cpu;
1123
1124         memset(&total, 0, sizeof(total));
1125         for_each_possible_cpu(cpu) {
1126                 cpu_stats = per_cpu_ptr(stats, cpu);
1127                 do {
1128                         seq = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
1129                         pkts = cpu_stats->pkts;
1130                         bytes = cpu_stats->bytes;
1131                 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, seq));
1132                 total.pkts += pkts;
1133                 total.bytes += bytes;
1134         }
1135         nest = nla_nest_start(skb, NFTA_CHAIN_COUNTERS);
1136         if (nest == NULL)
1137                 goto nla_put_failure;
1138
1139         if (nla_put_be64(skb, NFTA_COUNTER_PACKETS, cpu_to_be64(total.pkts),
1140                          NFTA_COUNTER_PAD) ||
1141             nla_put_be64(skb, NFTA_COUNTER_BYTES, cpu_to_be64(total.bytes),
1142                          NFTA_COUNTER_PAD))
1143                 goto nla_put_failure;
1144
1145         nla_nest_end(skb, nest);
1146         return 0;
1147
1148 nla_put_failure:
1149         return -ENOSPC;
1150 }
1151
1152 static int nf_tables_fill_chain_info(struct sk_buff *skb, struct net *net,
1153                                      u32 portid, u32 seq, int event, u32 flags,
1154                                      int family, const struct nft_table *table,
1155                                      const struct nft_chain *chain)
1156 {
1157         struct nlmsghdr *nlh;
1158         struct nfgenmsg *nfmsg;
1159
1160         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
1161         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags);
1162         if (nlh == NULL)
1163                 goto nla_put_failure;
1164
1165         nfmsg = nlmsg_data(nlh);
1166         nfmsg->nfgen_family     = family;
1167         nfmsg->version          = NFNETLINK_V0;
1168         nfmsg->res_id           = htons(net->nft.base_seq & 0xffff);
1169
1170         if (nla_put_string(skb, NFTA_CHAIN_TABLE, table->name))
1171                 goto nla_put_failure;
1172         if (nla_put_be64(skb, NFTA_CHAIN_HANDLE, cpu_to_be64(chain->handle),
1173                          NFTA_CHAIN_PAD))
1174                 goto nla_put_failure;
1175         if (nla_put_string(skb, NFTA_CHAIN_NAME, chain->name))
1176                 goto nla_put_failure;
1177
1178         if (nft_is_base_chain(chain)) {
1179                 const struct nft_base_chain *basechain = nft_base_chain(chain);
1180                 const struct nf_hook_ops *ops = &basechain->ops;
1181                 struct nlattr *nest;
1182
1183                 nest = nla_nest_start(skb, NFTA_CHAIN_HOOK);
1184                 if (nest == NULL)
1185                         goto nla_put_failure;
1186                 if (nla_put_be32(skb, NFTA_HOOK_HOOKNUM, htonl(ops->hooknum)))
1187                         goto nla_put_failure;
1188                 if (nla_put_be32(skb, NFTA_HOOK_PRIORITY, htonl(ops->priority)))
1189                         goto nla_put_failure;
1190                 if (basechain->dev_name[0] &&
1191                     nla_put_string(skb, NFTA_HOOK_DEV, basechain->dev_name))
1192                         goto nla_put_failure;
1193                 nla_nest_end(skb, nest);
1194
1195                 if (nla_put_be32(skb, NFTA_CHAIN_POLICY,
1196                                  htonl(basechain->policy)))
1197                         goto nla_put_failure;
1198
1199                 if (nla_put_string(skb, NFTA_CHAIN_TYPE, basechain->type->name))
1200                         goto nla_put_failure;
1201
1202                 if (basechain->stats && nft_dump_stats(skb, basechain->stats))
1203                         goto nla_put_failure;
1204         }
1205
1206         if (nla_put_be32(skb, NFTA_CHAIN_USE, htonl(chain->use)))
1207                 goto nla_put_failure;
1208
1209         nlmsg_end(skb, nlh);
1210         return 0;
1211
1212 nla_put_failure:
1213         nlmsg_trim(skb, nlh);
1214         return -1;
1215 }
1216
1217 static void nf_tables_chain_notify(const struct nft_ctx *ctx, int event)
1218 {
1219         struct sk_buff *skb;
1220         int err;
1221
1222         if (!ctx->report &&
1223             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
1224                 return;
1225
1226         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1227         if (skb == NULL)
1228                 goto err;
1229
1230         err = nf_tables_fill_chain_info(skb, ctx->net, ctx->portid, ctx->seq,
1231                                         event, 0, ctx->family, ctx->table,
1232                                         ctx->chain);
1233         if (err < 0) {
1234                 kfree_skb(skb);
1235                 goto err;
1236         }
1237
1238         nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
1239                        ctx->report, GFP_KERNEL);
1240         return;
1241 err:
1242         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
1243 }
1244
1245 static int nf_tables_dump_chains(struct sk_buff *skb,
1246                                  struct netlink_callback *cb)
1247 {
1248         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
1249         const struct nft_table *table;
1250         const struct nft_chain *chain;
1251         unsigned int idx = 0, s_idx = cb->args[0];
1252         struct net *net = sock_net(skb->sk);
1253         int family = nfmsg->nfgen_family;
1254
1255         rcu_read_lock();
1256         cb->seq = net->nft.base_seq;
1257
1258         list_for_each_entry_rcu(table, &net->nft.tables, list) {
1259                 if (family != NFPROTO_UNSPEC && family != table->family)
1260                         continue;
1261
1262                 list_for_each_entry_rcu(chain, &table->chains, list) {
1263                         if (idx < s_idx)
1264                                 goto cont;
1265                         if (idx > s_idx)
1266                                 memset(&cb->args[1], 0,
1267                                        sizeof(cb->args) - sizeof(cb->args[0]));
1268                         if (!nft_is_active(net, chain))
1269                                 continue;
1270                         if (nf_tables_fill_chain_info(skb, net,
1271                                                       NETLINK_CB(cb->skb).portid,
1272                                                       cb->nlh->nlmsg_seq,
1273                                                       NFT_MSG_NEWCHAIN,
1274                                                       NLM_F_MULTI,
1275                                                       table->family, table,
1276                                                       chain) < 0)
1277                                 goto done;
1278
1279                         nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1280 cont:
1281                         idx++;
1282                 }
1283         }
1284 done:
1285         rcu_read_unlock();
1286         cb->args[0] = idx;
1287         return skb->len;
1288 }
1289
1290 /* called with rcu_read_lock held */
1291 static int nf_tables_getchain(struct net *net, struct sock *nlsk,
1292                               struct sk_buff *skb, const struct nlmsghdr *nlh,
1293                               const struct nlattr * const nla[],
1294                               struct netlink_ext_ack *extack)
1295 {
1296         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1297         u8 genmask = nft_genmask_cur(net);
1298         const struct nft_chain *chain;
1299         struct nft_table *table;
1300         struct sk_buff *skb2;
1301         int family = nfmsg->nfgen_family;
1302         int err;
1303
1304         if (nlh->nlmsg_flags & NLM_F_DUMP) {
1305                 struct netlink_dump_control c = {
1306                         .dump = nf_tables_dump_chains,
1307                         .module = THIS_MODULE,
1308                 };
1309
1310                 return nft_netlink_dump_start_rcu(nlsk, skb, nlh, &c);
1311         }
1312
1313         table = nft_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, genmask);
1314         if (IS_ERR(table)) {
1315                 NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TABLE]);
1316                 return PTR_ERR(table);
1317         }
1318
1319         chain = nft_chain_lookup(net, table, nla[NFTA_CHAIN_NAME], genmask);
1320         if (IS_ERR(chain)) {
1321                 NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_NAME]);
1322                 return PTR_ERR(chain);
1323         }
1324
1325         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
1326         if (!skb2)
1327                 return -ENOMEM;
1328
1329         err = nf_tables_fill_chain_info(skb2, net, NETLINK_CB(skb).portid,
1330                                         nlh->nlmsg_seq, NFT_MSG_NEWCHAIN, 0,
1331                                         family, table, chain);
1332         if (err < 0)
1333                 goto err;
1334
1335         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
1336
1337 err:
1338         kfree_skb(skb2);
1339         return err;
1340 }
1341
1342 static const struct nla_policy nft_counter_policy[NFTA_COUNTER_MAX + 1] = {
1343         [NFTA_COUNTER_PACKETS]  = { .type = NLA_U64 },
1344         [NFTA_COUNTER_BYTES]    = { .type = NLA_U64 },
1345 };
1346
1347 static struct nft_stats __percpu *nft_stats_alloc(const struct nlattr *attr)
1348 {
1349         struct nlattr *tb[NFTA_COUNTER_MAX+1];
1350         struct nft_stats __percpu *newstats;
1351         struct nft_stats *stats;
1352         int err;
1353
1354         err = nla_parse_nested(tb, NFTA_COUNTER_MAX, attr, nft_counter_policy,
1355                                NULL);
1356         if (err < 0)
1357                 return ERR_PTR(err);
1358
1359         if (!tb[NFTA_COUNTER_BYTES] || !tb[NFTA_COUNTER_PACKETS])
1360                 return ERR_PTR(-EINVAL);
1361
1362         newstats = netdev_alloc_pcpu_stats(struct nft_stats);
1363         if (newstats == NULL)
1364                 return ERR_PTR(-ENOMEM);
1365
1366         /* Restore old counters on this cpu, no problem. Per-cpu statistics
1367          * are not exposed to userspace.
1368          */
1369         preempt_disable();
1370         stats = this_cpu_ptr(newstats);
1371         stats->bytes = be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_BYTES]));
1372         stats->pkts = be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_PACKETS]));
1373         preempt_enable();
1374
1375         return newstats;
1376 }
1377
1378 static void nft_chain_stats_replace(struct nft_base_chain *chain,
1379                                     struct nft_stats __percpu *newstats)
1380 {
1381         struct nft_stats __percpu *oldstats;
1382
1383         if (newstats == NULL)
1384                 return;
1385
1386         if (chain->stats) {
1387                 oldstats = nfnl_dereference(chain->stats, NFNL_SUBSYS_NFTABLES);
1388                 rcu_assign_pointer(chain->stats, newstats);
1389                 synchronize_rcu();
1390                 free_percpu(oldstats);
1391         } else {
1392                 rcu_assign_pointer(chain->stats, newstats);
1393                 static_branch_inc(&nft_counters_enabled);
1394         }
1395 }
1396
1397 static void nf_tables_chain_free_chain_rules(struct nft_chain *chain)
1398 {
1399         struct nft_rule **g0 = rcu_dereference_raw(chain->rules_gen_0);
1400         struct nft_rule **g1 = rcu_dereference_raw(chain->rules_gen_1);
1401
1402         if (g0 != g1)
1403                 kvfree(g1);
1404         kvfree(g0);
1405
1406         /* should be NULL either via abort or via successful commit */
1407         WARN_ON_ONCE(chain->rules_next);
1408         kvfree(chain->rules_next);
1409 }
1410
1411 static void nf_tables_chain_destroy(struct nft_ctx *ctx)
1412 {
1413         struct nft_chain *chain = ctx->chain;
1414
1415         BUG_ON(chain->use > 0);
1416
1417         /* no concurrent access possible anymore */
1418         nf_tables_chain_free_chain_rules(chain);
1419
1420         if (nft_is_base_chain(chain)) {
1421                 struct nft_base_chain *basechain = nft_base_chain(chain);
1422
1423                 module_put(basechain->type->owner);
1424                 free_percpu(basechain->stats);
1425                 if (basechain->stats)
1426                         static_branch_dec(&nft_counters_enabled);
1427                 kfree(chain->name);
1428                 kfree(basechain);
1429         } else {
1430                 kfree(chain->name);
1431                 kfree(chain);
1432         }
1433 }
1434
1435 struct nft_chain_hook {
1436         u32                             num;
1437         s32                             priority;
1438         const struct nft_chain_type     *type;
1439         struct net_device               *dev;
1440 };
1441
1442 static int nft_chain_parse_hook(struct net *net,
1443                                 const struct nlattr * const nla[],
1444                                 struct nft_chain_hook *hook, u8 family,
1445                                 bool autoload)
1446 {
1447         struct nlattr *ha[NFTA_HOOK_MAX + 1];
1448         const struct nft_chain_type *type;
1449         struct net_device *dev;
1450         int err;
1451
1452         lockdep_assert_held(&net->nft.commit_mutex);
1453         lockdep_nfnl_nft_mutex_not_held();
1454
1455         err = nla_parse_nested(ha, NFTA_HOOK_MAX, nla[NFTA_CHAIN_HOOK],
1456                                nft_hook_policy, NULL);
1457         if (err < 0)
1458                 return err;
1459
1460         if (ha[NFTA_HOOK_HOOKNUM] == NULL ||
1461             ha[NFTA_HOOK_PRIORITY] == NULL)
1462                 return -EINVAL;
1463
1464         hook->num = ntohl(nla_get_be32(ha[NFTA_HOOK_HOOKNUM]));
1465         hook->priority = ntohl(nla_get_be32(ha[NFTA_HOOK_PRIORITY]));
1466
1467         type = chain_type[family][NFT_CHAIN_T_DEFAULT];
1468         if (nla[NFTA_CHAIN_TYPE]) {
1469                 type = nf_tables_chain_type_lookup(net, nla[NFTA_CHAIN_TYPE],
1470                                                    family, autoload);
1471                 if (IS_ERR(type))
1472                         return PTR_ERR(type);
1473         }
1474         if (!(type->hook_mask & (1 << hook->num)))
1475                 return -EOPNOTSUPP;
1476
1477         if (type->type == NFT_CHAIN_T_NAT &&
1478             hook->priority <= NF_IP_PRI_CONNTRACK)
1479                 return -EOPNOTSUPP;
1480
1481         if (!try_module_get(type->owner))
1482                 return -ENOENT;
1483
1484         hook->type = type;
1485
1486         hook->dev = NULL;
1487         if (family == NFPROTO_NETDEV) {
1488                 char ifname[IFNAMSIZ];
1489
1490                 if (!ha[NFTA_HOOK_DEV]) {
1491                         module_put(type->owner);
1492                         return -EOPNOTSUPP;
1493                 }
1494
1495                 nla_strlcpy(ifname, ha[NFTA_HOOK_DEV], IFNAMSIZ);
1496                 dev = __dev_get_by_name(net, ifname);
1497                 if (!dev) {
1498                         module_put(type->owner);
1499                         return -ENOENT;
1500                 }
1501                 hook->dev = dev;
1502         } else if (ha[NFTA_HOOK_DEV]) {
1503                 module_put(type->owner);
1504                 return -EOPNOTSUPP;
1505         }
1506
1507         return 0;
1508 }
1509
1510 static void nft_chain_release_hook(struct nft_chain_hook *hook)
1511 {
1512         module_put(hook->type->owner);
1513 }
1514
1515 struct nft_rules_old {
1516         struct rcu_head h;
1517         struct nft_rule **start;
1518 };
1519
1520 static struct nft_rule **nf_tables_chain_alloc_rules(const struct nft_chain *chain,
1521                                                      unsigned int alloc)
1522 {
1523         if (alloc > INT_MAX)
1524                 return NULL;
1525
1526         alloc += 1;     /* NULL, ends rules */
1527         if (sizeof(struct nft_rule *) > INT_MAX / alloc)
1528                 return NULL;
1529
1530         alloc *= sizeof(struct nft_rule *);
1531         alloc += sizeof(struct nft_rules_old);
1532
1533         return kvmalloc(alloc, GFP_KERNEL);
1534 }
1535
1536 static int nf_tables_addchain(struct nft_ctx *ctx, u8 family, u8 genmask,
1537                               u8 policy)
1538 {
1539         const struct nlattr * const *nla = ctx->nla;
1540         struct nft_table *table = ctx->table;
1541         struct nft_base_chain *basechain;
1542         struct nft_stats __percpu *stats;
1543         struct net *net = ctx->net;
1544         struct nft_chain *chain;
1545         struct nft_rule **rules;
1546         int err;
1547
1548         if (table->use == UINT_MAX)
1549                 return -EOVERFLOW;
1550
1551         if (nla[NFTA_CHAIN_HOOK]) {
1552                 struct nft_chain_hook hook;
1553                 struct nf_hook_ops *ops;
1554
1555                 err = nft_chain_parse_hook(net, nla, &hook, family, true);
1556                 if (err < 0)
1557                         return err;
1558
1559                 basechain = kzalloc(sizeof(*basechain), GFP_KERNEL);
1560                 if (basechain == NULL) {
1561                         nft_chain_release_hook(&hook);
1562                         return -ENOMEM;
1563                 }
1564
1565                 if (hook.dev != NULL)
1566                         strncpy(basechain->dev_name, hook.dev->name, IFNAMSIZ);
1567
1568                 if (nla[NFTA_CHAIN_COUNTERS]) {
1569                         stats = nft_stats_alloc(nla[NFTA_CHAIN_COUNTERS]);
1570                         if (IS_ERR(stats)) {
1571                                 nft_chain_release_hook(&hook);
1572                                 kfree(basechain);
1573                                 return PTR_ERR(stats);
1574                         }
1575                         basechain->stats = stats;
1576                         static_branch_inc(&nft_counters_enabled);
1577                 }
1578
1579                 basechain->type = hook.type;
1580                 chain = &basechain->chain;
1581
1582                 ops             = &basechain->ops;
1583                 ops->pf         = family;
1584                 ops->hooknum    = hook.num;
1585                 ops->priority   = hook.priority;
1586                 ops->priv       = chain;
1587                 ops->hook       = hook.type->hooks[ops->hooknum];
1588                 ops->dev        = hook.dev;
1589
1590                 chain->flags |= NFT_BASE_CHAIN;
1591                 basechain->policy = policy;
1592         } else {
1593                 chain = kzalloc(sizeof(*chain), GFP_KERNEL);
1594                 if (chain == NULL)
1595                         return -ENOMEM;
1596         }
1597         ctx->chain = chain;
1598
1599         INIT_LIST_HEAD(&chain->rules);
1600         chain->handle = nf_tables_alloc_handle(table);
1601         chain->table = table;
1602         chain->name = nla_strdup(nla[NFTA_CHAIN_NAME], GFP_KERNEL);
1603         if (!chain->name) {
1604                 err = -ENOMEM;
1605                 goto err1;
1606         }
1607
1608         rules = nf_tables_chain_alloc_rules(chain, 0);
1609         if (!rules) {
1610                 err = -ENOMEM;
1611                 goto err1;
1612         }
1613
1614         *rules = NULL;
1615         rcu_assign_pointer(chain->rules_gen_0, rules);
1616         rcu_assign_pointer(chain->rules_gen_1, rules);
1617
1618         err = nf_tables_register_hook(net, table, chain);
1619         if (err < 0)
1620                 goto err1;
1621
1622         err = rhltable_insert_key(&table->chains_ht, chain->name,
1623                                   &chain->rhlhead, nft_chain_ht_params);
1624         if (err)
1625                 goto err2;
1626
1627         err = nft_trans_chain_add(ctx, NFT_MSG_NEWCHAIN);
1628         if (err < 0) {
1629                 rhltable_remove(&table->chains_ht, &chain->rhlhead,
1630                                 nft_chain_ht_params);
1631                 goto err2;
1632         }
1633
1634         table->use++;
1635         list_add_tail_rcu(&chain->list, &table->chains);
1636
1637         return 0;
1638 err2:
1639         nf_tables_unregister_hook(net, table, chain);
1640 err1:
1641         nf_tables_chain_destroy(ctx);
1642
1643         return err;
1644 }
1645
1646 static int nf_tables_updchain(struct nft_ctx *ctx, u8 genmask, u8 policy)
1647 {
1648         const struct nlattr * const *nla = ctx->nla;
1649         struct nft_table *table = ctx->table;
1650         struct nft_chain *chain = ctx->chain;
1651         struct nft_base_chain *basechain;
1652         struct nft_stats *stats = NULL;
1653         struct nft_chain_hook hook;
1654         struct nf_hook_ops *ops;
1655         struct nft_trans *trans;
1656         int err;
1657
1658         if (nla[NFTA_CHAIN_HOOK]) {
1659                 if (!nft_is_base_chain(chain))
1660                         return -EBUSY;
1661
1662                 err = nft_chain_parse_hook(ctx->net, nla, &hook, ctx->family,
1663                                            false);
1664                 if (err < 0)
1665                         return err;
1666
1667                 basechain = nft_base_chain(chain);
1668                 if (basechain->type != hook.type) {
1669                         nft_chain_release_hook(&hook);
1670                         return -EBUSY;
1671                 }
1672
1673                 ops = &basechain->ops;
1674                 if (ops->hooknum != hook.num ||
1675                     ops->priority != hook.priority ||
1676                     ops->dev != hook.dev) {
1677                         nft_chain_release_hook(&hook);
1678                         return -EBUSY;
1679                 }
1680                 nft_chain_release_hook(&hook);
1681         }
1682
1683         if (nla[NFTA_CHAIN_HANDLE] &&
1684             nla[NFTA_CHAIN_NAME]) {
1685                 struct nft_chain *chain2;
1686
1687                 chain2 = nft_chain_lookup(ctx->net, table,
1688                                           nla[NFTA_CHAIN_NAME], genmask);
1689                 if (!IS_ERR(chain2))
1690                         return -EEXIST;
1691         }
1692
1693         if (nla[NFTA_CHAIN_COUNTERS]) {
1694                 if (!nft_is_base_chain(chain))
1695                         return -EOPNOTSUPP;
1696
1697                 stats = nft_stats_alloc(nla[NFTA_CHAIN_COUNTERS]);
1698                 if (IS_ERR(stats))
1699                         return PTR_ERR(stats);
1700         }
1701
1702         err = -ENOMEM;
1703         trans = nft_trans_alloc(ctx, NFT_MSG_NEWCHAIN,
1704                                 sizeof(struct nft_trans_chain));
1705         if (trans == NULL)
1706                 goto err;
1707
1708         nft_trans_chain_stats(trans) = stats;
1709         nft_trans_chain_update(trans) = true;
1710
1711         if (nla[NFTA_CHAIN_POLICY])
1712                 nft_trans_chain_policy(trans) = policy;
1713         else
1714                 nft_trans_chain_policy(trans) = -1;
1715
1716         if (nla[NFTA_CHAIN_HANDLE] &&
1717             nla[NFTA_CHAIN_NAME]) {
1718                 struct nft_trans *tmp;
1719                 char *name;
1720
1721                 err = -ENOMEM;
1722                 name = nla_strdup(nla[NFTA_CHAIN_NAME], GFP_KERNEL);
1723                 if (!name)
1724                         goto err;
1725
1726                 err = -EEXIST;
1727                 list_for_each_entry(tmp, &ctx->net->nft.commit_list, list) {
1728                         if (tmp->msg_type == NFT_MSG_NEWCHAIN &&
1729                             tmp->ctx.table == table &&
1730                             nft_trans_chain_update(tmp) &&
1731                             nft_trans_chain_name(tmp) &&
1732                             strcmp(name, nft_trans_chain_name(tmp)) == 0) {
1733                                 kfree(name);
1734                                 goto err;
1735                         }
1736                 }
1737
1738                 nft_trans_chain_name(trans) = name;
1739         }
1740         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
1741
1742         return 0;
1743 err:
1744         free_percpu(stats);
1745         kfree(trans);
1746         return err;
1747 }
1748
1749 static int nf_tables_newchain(struct net *net, struct sock *nlsk,
1750                               struct sk_buff *skb, const struct nlmsghdr *nlh,
1751                               const struct nlattr * const nla[],
1752                               struct netlink_ext_ack *extack)
1753 {
1754         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1755         u8 genmask = nft_genmask_next(net);
1756         int family = nfmsg->nfgen_family;
1757         const struct nlattr *attr;
1758         struct nft_table *table;
1759         struct nft_chain *chain;
1760         u8 policy = NF_ACCEPT;
1761         struct nft_ctx ctx;
1762         u64 handle = 0;
1763
1764         lockdep_assert_held(&net->nft.commit_mutex);
1765
1766         table = nft_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, genmask);
1767         if (IS_ERR(table)) {
1768                 NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TABLE]);
1769                 return PTR_ERR(table);
1770         }
1771
1772         chain = NULL;
1773         attr = nla[NFTA_CHAIN_NAME];
1774
1775         if (nla[NFTA_CHAIN_HANDLE]) {
1776                 handle = be64_to_cpu(nla_get_be64(nla[NFTA_CHAIN_HANDLE]));
1777                 chain = nft_chain_lookup_byhandle(table, handle, genmask);
1778                 if (IS_ERR(chain)) {
1779                         NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_HANDLE]);
1780                         return PTR_ERR(chain);
1781                 }
1782                 attr = nla[NFTA_CHAIN_HANDLE];
1783         } else {
1784                 chain = nft_chain_lookup(net, table, attr, genmask);
1785                 if (IS_ERR(chain)) {
1786                         if (PTR_ERR(chain) != -ENOENT) {
1787                                 NL_SET_BAD_ATTR(extack, attr);
1788                                 return PTR_ERR(chain);
1789                         }
1790                         chain = NULL;
1791                 }
1792         }
1793
1794         if (nla[NFTA_CHAIN_POLICY]) {
1795                 if (chain != NULL &&
1796                     !nft_is_base_chain(chain)) {
1797                         NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_POLICY]);
1798                         return -EOPNOTSUPP;
1799                 }
1800
1801                 if (chain == NULL &&
1802                     nla[NFTA_CHAIN_HOOK] == NULL) {
1803                         NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_POLICY]);
1804                         return -EOPNOTSUPP;
1805                 }
1806
1807                 policy = ntohl(nla_get_be32(nla[NFTA_CHAIN_POLICY]));
1808                 switch (policy) {
1809                 case NF_DROP:
1810                 case NF_ACCEPT:
1811                         break;
1812                 default:
1813                         return -EINVAL;
1814                 }
1815         }
1816
1817         nft_ctx_init(&ctx, net, skb, nlh, family, table, chain, nla);
1818
1819         if (chain != NULL) {
1820                 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1821                         NL_SET_BAD_ATTR(extack, attr);
1822                         return -EEXIST;
1823                 }
1824                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
1825                         return -EOPNOTSUPP;
1826
1827                 return nf_tables_updchain(&ctx, genmask, policy);
1828         }
1829
1830         return nf_tables_addchain(&ctx, family, genmask, policy);
1831 }
1832
1833 static int nf_tables_delchain(struct net *net, struct sock *nlsk,
1834                               struct sk_buff *skb, const struct nlmsghdr *nlh,
1835                               const struct nlattr * const nla[],
1836                               struct netlink_ext_ack *extack)
1837 {
1838         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1839         u8 genmask = nft_genmask_next(net);
1840         int family = nfmsg->nfgen_family;
1841         const struct nlattr *attr;
1842         struct nft_table *table;
1843         struct nft_chain *chain;
1844         struct nft_rule *rule;
1845         struct nft_ctx ctx;
1846         u64 handle;
1847         u32 use;
1848         int err;
1849
1850         table = nft_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, genmask);
1851         if (IS_ERR(table)) {
1852                 NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TABLE]);
1853                 return PTR_ERR(table);
1854         }
1855
1856         if (nla[NFTA_CHAIN_HANDLE]) {
1857                 attr = nla[NFTA_CHAIN_HANDLE];
1858                 handle = be64_to_cpu(nla_get_be64(attr));
1859                 chain = nft_chain_lookup_byhandle(table, handle, genmask);
1860         } else {
1861                 attr = nla[NFTA_CHAIN_NAME];
1862                 chain = nft_chain_lookup(net, table, attr, genmask);
1863         }
1864         if (IS_ERR(chain)) {
1865                 NL_SET_BAD_ATTR(extack, attr);
1866                 return PTR_ERR(chain);
1867         }
1868
1869         if (nlh->nlmsg_flags & NLM_F_NONREC &&
1870             chain->use > 0)
1871                 return -EBUSY;
1872
1873         nft_ctx_init(&ctx, net, skb, nlh, family, table, chain, nla);
1874
1875         use = chain->use;
1876         list_for_each_entry(rule, &chain->rules, list) {
1877                 if (!nft_is_active_next(net, rule))
1878                         continue;
1879                 use--;
1880
1881                 err = nft_delrule(&ctx, rule);
1882                 if (err < 0)
1883                         return err;
1884         }
1885
1886         /* There are rules and elements that are still holding references to us,
1887          * we cannot do a recursive removal in this case.
1888          */
1889         if (use > 0) {
1890                 NL_SET_BAD_ATTR(extack, attr);
1891                 return -EBUSY;
1892         }
1893
1894         return nft_delchain(&ctx);
1895 }
1896
1897 /*
1898  * Expressions
1899  */
1900
1901 /**
1902  *      nft_register_expr - register nf_tables expr type
1903  *      @ops: expr type
1904  *
1905  *      Registers the expr type for use with nf_tables. Returns zero on
1906  *      success or a negative errno code otherwise.
1907  */
1908 int nft_register_expr(struct nft_expr_type *type)
1909 {
1910         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1911         if (type->family == NFPROTO_UNSPEC)
1912                 list_add_tail_rcu(&type->list, &nf_tables_expressions);
1913         else
1914                 list_add_rcu(&type->list, &nf_tables_expressions);
1915         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1916         return 0;
1917 }
1918 EXPORT_SYMBOL_GPL(nft_register_expr);
1919
1920 /**
1921  *      nft_unregister_expr - unregister nf_tables expr type
1922  *      @ops: expr type
1923  *
1924  *      Unregisters the expr typefor use with nf_tables.
1925  */
1926 void nft_unregister_expr(struct nft_expr_type *type)
1927 {
1928         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1929         list_del_rcu(&type->list);
1930         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1931 }
1932 EXPORT_SYMBOL_GPL(nft_unregister_expr);
1933
1934 static const struct nft_expr_type *__nft_expr_type_get(u8 family,
1935                                                        struct nlattr *nla)
1936 {
1937         const struct nft_expr_type *type;
1938
1939         list_for_each_entry(type, &nf_tables_expressions, list) {
1940                 if (!nla_strcmp(nla, type->name) &&
1941                     (!type->family || type->family == family))
1942                         return type;
1943         }
1944         return NULL;
1945 }
1946
1947 static const struct nft_expr_type *nft_expr_type_get(struct net *net,
1948                                                      u8 family,
1949                                                      struct nlattr *nla)
1950 {
1951         const struct nft_expr_type *type;
1952
1953         if (nla == NULL)
1954                 return ERR_PTR(-EINVAL);
1955
1956         type = __nft_expr_type_get(family, nla);
1957         if (type != NULL && try_module_get(type->owner))
1958                 return type;
1959
1960         lockdep_nfnl_nft_mutex_not_held();
1961 #ifdef CONFIG_MODULES
1962         if (type == NULL) {
1963                 nft_request_module(net, "nft-expr-%u-%.*s", family,
1964                                    nla_len(nla), (char *)nla_data(nla));
1965                 if (__nft_expr_type_get(family, nla))
1966                         return ERR_PTR(-EAGAIN);
1967
1968                 nft_request_module(net, "nft-expr-%.*s",
1969                                    nla_len(nla), (char *)nla_data(nla));
1970                 if (__nft_expr_type_get(family, nla))
1971                         return ERR_PTR(-EAGAIN);
1972         }
1973 #endif
1974         return ERR_PTR(-ENOENT);
1975 }
1976
1977 static const struct nla_policy nft_expr_policy[NFTA_EXPR_MAX + 1] = {
1978         [NFTA_EXPR_NAME]        = { .type = NLA_STRING },
1979         [NFTA_EXPR_DATA]        = { .type = NLA_NESTED },
1980 };
1981
1982 static int nf_tables_fill_expr_info(struct sk_buff *skb,
1983                                     const struct nft_expr *expr)
1984 {
1985         if (nla_put_string(skb, NFTA_EXPR_NAME, expr->ops->type->name))
1986                 goto nla_put_failure;
1987
1988         if (expr->ops->dump) {
1989                 struct nlattr *data = nla_nest_start(skb, NFTA_EXPR_DATA);
1990                 if (data == NULL)
1991                         goto nla_put_failure;
1992                 if (expr->ops->dump(skb, expr) < 0)
1993                         goto nla_put_failure;
1994                 nla_nest_end(skb, data);
1995         }
1996
1997         return skb->len;
1998
1999 nla_put_failure:
2000         return -1;
2001 };
2002
2003 int nft_expr_dump(struct sk_buff *skb, unsigned int attr,
2004                   const struct nft_expr *expr)
2005 {
2006         struct nlattr *nest;
2007
2008         nest = nla_nest_start(skb, attr);
2009         if (!nest)
2010                 goto nla_put_failure;
2011         if (nf_tables_fill_expr_info(skb, expr) < 0)
2012                 goto nla_put_failure;
2013         nla_nest_end(skb, nest);
2014         return 0;
2015
2016 nla_put_failure:
2017         return -1;
2018 }
2019
2020 struct nft_expr_info {
2021         const struct nft_expr_ops       *ops;
2022         struct nlattr                   *tb[NFT_EXPR_MAXATTR + 1];
2023 };
2024
2025 static int nf_tables_expr_parse(const struct nft_ctx *ctx,
2026                                 const struct nlattr *nla,
2027                                 struct nft_expr_info *info)
2028 {
2029         const struct nft_expr_type *type;
2030         const struct nft_expr_ops *ops;
2031         struct nlattr *tb[NFTA_EXPR_MAX + 1];
2032         int err;
2033
2034         err = nla_parse_nested(tb, NFTA_EXPR_MAX, nla, nft_expr_policy, NULL);
2035         if (err < 0)
2036                 return err;
2037
2038         type = nft_expr_type_get(ctx->net, ctx->family, tb[NFTA_EXPR_NAME]);
2039         if (IS_ERR(type))
2040                 return PTR_ERR(type);
2041
2042         if (tb[NFTA_EXPR_DATA]) {
2043                 err = nla_parse_nested(info->tb, type->maxattr,
2044                                        tb[NFTA_EXPR_DATA], type->policy, NULL);
2045                 if (err < 0)
2046                         goto err1;
2047         } else
2048                 memset(info->tb, 0, sizeof(info->tb[0]) * (type->maxattr + 1));
2049
2050         if (type->select_ops != NULL) {
2051                 ops = type->select_ops(ctx,
2052                                        (const struct nlattr * const *)info->tb);
2053                 if (IS_ERR(ops)) {
2054                         err = PTR_ERR(ops);
2055                         goto err1;
2056                 }
2057         } else
2058                 ops = type->ops;
2059
2060         info->ops = ops;
2061         return 0;
2062
2063 err1:
2064         module_put(type->owner);
2065         return err;
2066 }
2067
2068 static int nf_tables_newexpr(const struct nft_ctx *ctx,
2069                              const struct nft_expr_info *info,
2070                              struct nft_expr *expr)
2071 {
2072         const struct nft_expr_ops *ops = info->ops;
2073         int err;
2074
2075         expr->ops = ops;
2076         if (ops->init) {
2077                 err = ops->init(ctx, expr, (const struct nlattr **)info->tb);
2078                 if (err < 0)
2079                         goto err1;
2080         }
2081
2082         return 0;
2083 err1:
2084         expr->ops = NULL;
2085         return err;
2086 }
2087
2088 static void nf_tables_expr_destroy(const struct nft_ctx *ctx,
2089                                    struct nft_expr *expr)
2090 {
2091         if (expr->ops->destroy)
2092                 expr->ops->destroy(ctx, expr);
2093         module_put(expr->ops->type->owner);
2094 }
2095
2096 struct nft_expr *nft_expr_init(const struct nft_ctx *ctx,
2097                                const struct nlattr *nla)
2098 {
2099         struct nft_expr_info info;
2100         struct nft_expr *expr;
2101         int err;
2102
2103         err = nf_tables_expr_parse(ctx, nla, &info);
2104         if (err < 0)
2105                 goto err1;
2106
2107         err = -ENOMEM;
2108         expr = kzalloc(info.ops->size, GFP_KERNEL);
2109         if (expr == NULL)
2110                 goto err2;
2111
2112         err = nf_tables_newexpr(ctx, &info, expr);
2113         if (err < 0)
2114                 goto err3;
2115
2116         return expr;
2117 err3:
2118         kfree(expr);
2119 err2:
2120         module_put(info.ops->type->owner);
2121 err1:
2122         return ERR_PTR(err);
2123 }
2124
2125 void nft_expr_destroy(const struct nft_ctx *ctx, struct nft_expr *expr)
2126 {
2127         nf_tables_expr_destroy(ctx, expr);
2128         kfree(expr);
2129 }
2130
2131 /*
2132  * Rules
2133  */
2134
2135 static struct nft_rule *__nft_rule_lookup(const struct nft_chain *chain,
2136                                           u64 handle)
2137 {
2138         struct nft_rule *rule;
2139
2140         // FIXME: this sucks
2141         list_for_each_entry_rcu(rule, &chain->rules, list) {
2142                 if (handle == rule->handle)
2143                         return rule;
2144         }
2145
2146         return ERR_PTR(-ENOENT);
2147 }
2148
2149 static struct nft_rule *nft_rule_lookup(const struct nft_chain *chain,
2150                                         const struct nlattr *nla)
2151 {
2152         if (nla == NULL)
2153                 return ERR_PTR(-EINVAL);
2154
2155         return __nft_rule_lookup(chain, be64_to_cpu(nla_get_be64(nla)));
2156 }
2157
2158 static const struct nla_policy nft_rule_policy[NFTA_RULE_MAX + 1] = {
2159         [NFTA_RULE_TABLE]       = { .type = NLA_STRING,
2160                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
2161         [NFTA_RULE_CHAIN]       = { .type = NLA_STRING,
2162                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
2163         [NFTA_RULE_HANDLE]      = { .type = NLA_U64 },
2164         [NFTA_RULE_EXPRESSIONS] = { .type = NLA_NESTED },
2165         [NFTA_RULE_COMPAT]      = { .type = NLA_NESTED },
2166         [NFTA_RULE_POSITION]    = { .type = NLA_U64 },
2167         [NFTA_RULE_USERDATA]    = { .type = NLA_BINARY,
2168                                     .len = NFT_USERDATA_MAXLEN },
2169         [NFTA_RULE_ID]          = { .type = NLA_U32 },
2170 };
2171
2172 static int nf_tables_fill_rule_info(struct sk_buff *skb, struct net *net,
2173                                     u32 portid, u32 seq, int event,
2174                                     u32 flags, int family,
2175                                     const struct nft_table *table,
2176                                     const struct nft_chain *chain,
2177                                     const struct nft_rule *rule)
2178 {
2179         struct nlmsghdr *nlh;
2180         struct nfgenmsg *nfmsg;
2181         const struct nft_expr *expr, *next;
2182         struct nlattr *list;
2183         const struct nft_rule *prule;
2184         u16 type = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
2185
2186         nlh = nlmsg_put(skb, portid, seq, type, sizeof(struct nfgenmsg), flags);
2187         if (nlh == NULL)
2188                 goto nla_put_failure;
2189
2190         nfmsg = nlmsg_data(nlh);
2191         nfmsg->nfgen_family     = family;
2192         nfmsg->version          = NFNETLINK_V0;
2193         nfmsg->res_id           = htons(net->nft.base_seq & 0xffff);
2194
2195         if (nla_put_string(skb, NFTA_RULE_TABLE, table->name))
2196                 goto nla_put_failure;
2197         if (nla_put_string(skb, NFTA_RULE_CHAIN, chain->name))
2198                 goto nla_put_failure;
2199         if (nla_put_be64(skb, NFTA_RULE_HANDLE, cpu_to_be64(rule->handle),
2200                          NFTA_RULE_PAD))
2201                 goto nla_put_failure;
2202
2203         if ((event != NFT_MSG_DELRULE) && (rule->list.prev != &chain->rules)) {
2204                 prule = list_prev_entry(rule, list);
2205                 if (nla_put_be64(skb, NFTA_RULE_POSITION,
2206                                  cpu_to_be64(prule->handle),
2207                                  NFTA_RULE_PAD))
2208                         goto nla_put_failure;
2209         }
2210
2211         list = nla_nest_start(skb, NFTA_RULE_EXPRESSIONS);
2212         if (list == NULL)
2213                 goto nla_put_failure;
2214         nft_rule_for_each_expr(expr, next, rule) {
2215                 if (nft_expr_dump(skb, NFTA_LIST_ELEM, expr) < 0)
2216                         goto nla_put_failure;
2217         }
2218         nla_nest_end(skb, list);
2219
2220         if (rule->udata) {
2221                 struct nft_userdata *udata = nft_userdata(rule);
2222                 if (nla_put(skb, NFTA_RULE_USERDATA, udata->len + 1,
2223                             udata->data) < 0)
2224                         goto nla_put_failure;
2225         }
2226
2227         nlmsg_end(skb, nlh);
2228         return 0;
2229
2230 nla_put_failure:
2231         nlmsg_trim(skb, nlh);
2232         return -1;
2233 }
2234
2235 static void nf_tables_rule_notify(const struct nft_ctx *ctx,
2236                                   const struct nft_rule *rule, int event)
2237 {
2238         struct sk_buff *skb;
2239         int err;
2240
2241         if (!ctx->report &&
2242             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
2243                 return;
2244
2245         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
2246         if (skb == NULL)
2247                 goto err;
2248
2249         err = nf_tables_fill_rule_info(skb, ctx->net, ctx->portid, ctx->seq,
2250                                        event, 0, ctx->family, ctx->table,
2251                                        ctx->chain, rule);
2252         if (err < 0) {
2253                 kfree_skb(skb);
2254                 goto err;
2255         }
2256
2257         nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
2258                        ctx->report, GFP_KERNEL);
2259         return;
2260 err:
2261         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
2262 }
2263
2264 struct nft_rule_dump_ctx {
2265         char *table;
2266         char *chain;
2267 };
2268
2269 static int nf_tables_dump_rules(struct sk_buff *skb,
2270                                 struct netlink_callback *cb)
2271 {
2272         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
2273         const struct nft_rule_dump_ctx *ctx = cb->data;
2274         const struct nft_table *table;
2275         const struct nft_chain *chain;
2276         const struct nft_rule *rule;
2277         unsigned int idx = 0, s_idx = cb->args[0];
2278         struct net *net = sock_net(skb->sk);
2279         int family = nfmsg->nfgen_family;
2280
2281         rcu_read_lock();
2282         cb->seq = net->nft.base_seq;
2283
2284         list_for_each_entry_rcu(table, &net->nft.tables, list) {
2285                 if (family != NFPROTO_UNSPEC && family != table->family)
2286                         continue;
2287
2288                 if (ctx && ctx->table && strcmp(ctx->table, table->name) != 0)
2289                         continue;
2290
2291                 list_for_each_entry_rcu(chain, &table->chains, list) {
2292                         if (ctx && ctx->chain &&
2293                             strcmp(ctx->chain, chain->name) != 0)
2294                                 continue;
2295
2296                         list_for_each_entry_rcu(rule, &chain->rules, list) {
2297                                 if (!nft_is_active(net, rule))
2298                                         goto cont;
2299                                 if (idx < s_idx)
2300                                         goto cont;
2301                                 if (idx > s_idx)
2302                                         memset(&cb->args[1], 0,
2303                                                sizeof(cb->args) - sizeof(cb->args[0]));
2304                                 if (nf_tables_fill_rule_info(skb, net, NETLINK_CB(cb->skb).portid,
2305                                                               cb->nlh->nlmsg_seq,
2306                                                               NFT_MSG_NEWRULE,
2307                                                               NLM_F_MULTI | NLM_F_APPEND,
2308                                                               table->family,
2309                                                               table, chain, rule) < 0)
2310                                         goto done;
2311
2312                                 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2313 cont:
2314                                 idx++;
2315                         }
2316                 }
2317         }
2318 done:
2319         rcu_read_unlock();
2320
2321         cb->args[0] = idx;
2322         return skb->len;
2323 }
2324
2325 static int nf_tables_dump_rules_start(struct netlink_callback *cb)
2326 {
2327         const struct nlattr * const *nla = cb->data;
2328         struct nft_rule_dump_ctx *ctx = NULL;
2329
2330         if (nla[NFTA_RULE_TABLE] || nla[NFTA_RULE_CHAIN]) {
2331                 ctx = kzalloc(sizeof(*ctx), GFP_ATOMIC);
2332                 if (!ctx)
2333                         return -ENOMEM;
2334
2335                 if (nla[NFTA_RULE_TABLE]) {
2336                         ctx->table = nla_strdup(nla[NFTA_RULE_TABLE],
2337                                                         GFP_ATOMIC);
2338                         if (!ctx->table) {
2339                                 kfree(ctx);
2340                                 return -ENOMEM;
2341                         }
2342                 }
2343                 if (nla[NFTA_RULE_CHAIN]) {
2344                         ctx->chain = nla_strdup(nla[NFTA_RULE_CHAIN],
2345                                                 GFP_ATOMIC);
2346                         if (!ctx->chain) {
2347                                 kfree(ctx->table);
2348                                 kfree(ctx);
2349                                 return -ENOMEM;
2350                         }
2351                 }
2352         }
2353
2354         cb->data = ctx;
2355         return 0;
2356 }
2357
2358 static int nf_tables_dump_rules_done(struct netlink_callback *cb)
2359 {
2360         struct nft_rule_dump_ctx *ctx = cb->data;
2361
2362         if (ctx) {
2363                 kfree(ctx->table);
2364                 kfree(ctx->chain);
2365                 kfree(ctx);
2366         }
2367         return 0;
2368 }
2369
2370 /* called with rcu_read_lock held */
2371 static int nf_tables_getrule(struct net *net, struct sock *nlsk,
2372                              struct sk_buff *skb, const struct nlmsghdr *nlh,
2373                              const struct nlattr * const nla[],
2374                              struct netlink_ext_ack *extack)
2375 {
2376         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2377         u8 genmask = nft_genmask_cur(net);
2378         const struct nft_chain *chain;
2379         const struct nft_rule *rule;
2380         struct nft_table *table;
2381         struct sk_buff *skb2;
2382         int family = nfmsg->nfgen_family;
2383         int err;
2384
2385         if (nlh->nlmsg_flags & NLM_F_DUMP) {
2386                 struct netlink_dump_control c = {
2387                         .start= nf_tables_dump_rules_start,
2388                         .dump = nf_tables_dump_rules,
2389                         .done = nf_tables_dump_rules_done,
2390                         .module = THIS_MODULE,
2391                         .data = (void *)nla,
2392                 };
2393
2394                 return nft_netlink_dump_start_rcu(nlsk, skb, nlh, &c);
2395         }
2396
2397         table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask);
2398         if (IS_ERR(table)) {
2399                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_TABLE]);
2400                 return PTR_ERR(table);
2401         }
2402
2403         chain = nft_chain_lookup(net, table, nla[NFTA_RULE_CHAIN], genmask);
2404         if (IS_ERR(chain)) {
2405                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_CHAIN]);
2406                 return PTR_ERR(chain);
2407         }
2408
2409         rule = nft_rule_lookup(chain, nla[NFTA_RULE_HANDLE]);
2410         if (IS_ERR(rule)) {
2411                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_HANDLE]);
2412                 return PTR_ERR(rule);
2413         }
2414
2415         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
2416         if (!skb2)
2417                 return -ENOMEM;
2418
2419         err = nf_tables_fill_rule_info(skb2, net, NETLINK_CB(skb).portid,
2420                                        nlh->nlmsg_seq, NFT_MSG_NEWRULE, 0,
2421                                        family, table, chain, rule);
2422         if (err < 0)
2423                 goto err;
2424
2425         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
2426
2427 err:
2428         kfree_skb(skb2);
2429         return err;
2430 }
2431
2432 static void nf_tables_rule_destroy(const struct nft_ctx *ctx,
2433                                    struct nft_rule *rule)
2434 {
2435         struct nft_expr *expr;
2436
2437         lockdep_assert_held(&ctx->net->nft.commit_mutex);
2438         /*
2439          * Careful: some expressions might not be initialized in case this
2440          * is called on error from nf_tables_newrule().
2441          */
2442         expr = nft_expr_first(rule);
2443         while (expr != nft_expr_last(rule) && expr->ops) {
2444                 nf_tables_expr_destroy(ctx, expr);
2445                 expr = nft_expr_next(expr);
2446         }
2447         kfree(rule);
2448 }
2449
2450 static void nf_tables_rule_release(const struct nft_ctx *ctx,
2451                                    struct nft_rule *rule)
2452 {
2453         nft_rule_expr_deactivate(ctx, rule);
2454         nf_tables_rule_destroy(ctx, rule);
2455 }
2456
2457 int nft_chain_validate(const struct nft_ctx *ctx, const struct nft_chain *chain)
2458 {
2459         struct nft_expr *expr, *last;
2460         const struct nft_data *data;
2461         struct nft_rule *rule;
2462         int err;
2463
2464         if (ctx->level == NFT_JUMP_STACK_SIZE)
2465                 return -EMLINK;
2466
2467         list_for_each_entry(rule, &chain->rules, list) {
2468                 if (!nft_is_active_next(ctx->net, rule))
2469                         continue;
2470
2471                 nft_rule_for_each_expr(expr, last, rule) {
2472                         if (!expr->ops->validate)
2473                                 continue;
2474
2475                         err = expr->ops->validate(ctx, expr, &data);
2476                         if (err < 0)
2477                                 return err;
2478                 }
2479         }
2480
2481         return 0;
2482 }
2483 EXPORT_SYMBOL_GPL(nft_chain_validate);
2484
2485 static int nft_table_validate(struct net *net, const struct nft_table *table)
2486 {
2487         struct nft_chain *chain;
2488         struct nft_ctx ctx = {
2489                 .net    = net,
2490                 .family = table->family,
2491         };
2492         int err;
2493
2494         list_for_each_entry(chain, &table->chains, list) {
2495                 if (!nft_is_base_chain(chain))
2496                         continue;
2497
2498                 ctx.chain = chain;
2499                 err = nft_chain_validate(&ctx, chain);
2500                 if (err < 0)
2501                         return err;
2502         }
2503
2504         return 0;
2505 }
2506
2507 #define NFT_RULE_MAXEXPRS       128
2508
2509 static int nf_tables_newrule(struct net *net, struct sock *nlsk,
2510                              struct sk_buff *skb, const struct nlmsghdr *nlh,
2511                              const struct nlattr * const nla[],
2512                              struct netlink_ext_ack *extack)
2513 {
2514         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2515         u8 genmask = nft_genmask_next(net);
2516         struct nft_expr_info *info = NULL;
2517         int family = nfmsg->nfgen_family;
2518         struct nft_table *table;
2519         struct nft_chain *chain;
2520         struct nft_rule *rule, *old_rule = NULL;
2521         struct nft_userdata *udata;
2522         struct nft_trans *trans = NULL;
2523         struct nft_expr *expr;
2524         struct nft_ctx ctx;
2525         struct nlattr *tmp;
2526         unsigned int size, i, n, ulen = 0, usize = 0;
2527         int err, rem;
2528         u64 handle, pos_handle;
2529
2530         lockdep_assert_held(&net->nft.commit_mutex);
2531
2532         table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask);
2533         if (IS_ERR(table)) {
2534                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_TABLE]);
2535                 return PTR_ERR(table);
2536         }
2537
2538         chain = nft_chain_lookup(net, table, nla[NFTA_RULE_CHAIN], genmask);
2539         if (IS_ERR(chain)) {
2540                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_CHAIN]);
2541                 return PTR_ERR(chain);
2542         }
2543
2544         if (nla[NFTA_RULE_HANDLE]) {
2545                 handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_HANDLE]));
2546                 rule = __nft_rule_lookup(chain, handle);
2547                 if (IS_ERR(rule)) {
2548                         NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_HANDLE]);
2549                         return PTR_ERR(rule);
2550                 }
2551
2552                 if (nlh->nlmsg_flags & NLM_F_EXCL) {
2553                         NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_HANDLE]);
2554                         return -EEXIST;
2555                 }
2556                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
2557                         old_rule = rule;
2558                 else
2559                         return -EOPNOTSUPP;
2560         } else {
2561                 if (!(nlh->nlmsg_flags & NLM_F_CREATE) ||
2562                     nlh->nlmsg_flags & NLM_F_REPLACE)
2563                         return -EINVAL;
2564                 handle = nf_tables_alloc_handle(table);
2565
2566                 if (chain->use == UINT_MAX)
2567                         return -EOVERFLOW;
2568         }
2569
2570         if (nla[NFTA_RULE_POSITION]) {
2571                 if (!(nlh->nlmsg_flags & NLM_F_CREATE))
2572                         return -EOPNOTSUPP;
2573
2574                 pos_handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_POSITION]));
2575                 old_rule = __nft_rule_lookup(chain, pos_handle);
2576                 if (IS_ERR(old_rule)) {
2577                         NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_POSITION]);
2578                         return PTR_ERR(old_rule);
2579                 }
2580         }
2581
2582         nft_ctx_init(&ctx, net, skb, nlh, family, table, chain, nla);
2583
2584         n = 0;
2585         size = 0;
2586         if (nla[NFTA_RULE_EXPRESSIONS]) {
2587                 info = kvmalloc_array(NFT_RULE_MAXEXPRS,
2588                                       sizeof(struct nft_expr_info),
2589                                       GFP_KERNEL);
2590                 if (!info)
2591                         return -ENOMEM;
2592
2593                 nla_for_each_nested(tmp, nla[NFTA_RULE_EXPRESSIONS], rem) {
2594                         err = -EINVAL;
2595                         if (nla_type(tmp) != NFTA_LIST_ELEM)
2596                                 goto err1;
2597                         if (n == NFT_RULE_MAXEXPRS)
2598                                 goto err1;
2599                         err = nf_tables_expr_parse(&ctx, tmp, &info[n]);
2600                         if (err < 0)
2601                                 goto err1;
2602                         size += info[n].ops->size;
2603                         n++;
2604                 }
2605         }
2606         /* Check for overflow of dlen field */
2607         err = -EFBIG;
2608         if (size >= 1 << 12)
2609                 goto err1;
2610
2611         if (nla[NFTA_RULE_USERDATA]) {
2612                 ulen = nla_len(nla[NFTA_RULE_USERDATA]);
2613                 if (ulen > 0)
2614                         usize = sizeof(struct nft_userdata) + ulen;
2615         }
2616
2617         err = -ENOMEM;
2618         rule = kzalloc(sizeof(*rule) + size + usize, GFP_KERNEL);
2619         if (rule == NULL)
2620                 goto err1;
2621
2622         nft_activate_next(net, rule);
2623
2624         rule->handle = handle;
2625         rule->dlen   = size;
2626         rule->udata  = ulen ? 1 : 0;
2627
2628         if (ulen) {
2629                 udata = nft_userdata(rule);
2630                 udata->len = ulen - 1;
2631                 nla_memcpy(udata->data, nla[NFTA_RULE_USERDATA], ulen);
2632         }
2633
2634         expr = nft_expr_first(rule);
2635         for (i = 0; i < n; i++) {
2636                 err = nf_tables_newexpr(&ctx, &info[i], expr);
2637                 if (err < 0)
2638                         goto err2;
2639
2640                 if (info[i].ops->validate)
2641                         nft_validate_state_update(net, NFT_VALIDATE_NEED);
2642
2643                 info[i].ops = NULL;
2644                 expr = nft_expr_next(expr);
2645         }
2646
2647         if (nlh->nlmsg_flags & NLM_F_REPLACE) {
2648                 if (!nft_is_active_next(net, old_rule)) {
2649                         err = -ENOENT;
2650                         goto err2;
2651                 }
2652                 trans = nft_trans_rule_add(&ctx, NFT_MSG_DELRULE,
2653                                            old_rule);
2654                 if (trans == NULL) {
2655                         err = -ENOMEM;
2656                         goto err2;
2657                 }
2658                 nft_deactivate_next(net, old_rule);
2659                 chain->use--;
2660
2661                 if (nft_trans_rule_add(&ctx, NFT_MSG_NEWRULE, rule) == NULL) {
2662                         err = -ENOMEM;
2663                         goto err2;
2664                 }
2665
2666                 list_add_tail_rcu(&rule->list, &old_rule->list);
2667         } else {
2668                 if (nft_trans_rule_add(&ctx, NFT_MSG_NEWRULE, rule) == NULL) {
2669                         err = -ENOMEM;
2670                         goto err2;
2671                 }
2672
2673                 if (nlh->nlmsg_flags & NLM_F_APPEND) {
2674                         if (old_rule)
2675                                 list_add_rcu(&rule->list, &old_rule->list);
2676                         else
2677                                 list_add_tail_rcu(&rule->list, &chain->rules);
2678                  } else {
2679                         if (old_rule)
2680                                 list_add_tail_rcu(&rule->list, &old_rule->list);
2681                         else
2682                                 list_add_rcu(&rule->list, &chain->rules);
2683                 }
2684         }
2685         kvfree(info);
2686         chain->use++;
2687
2688         if (net->nft.validate_state == NFT_VALIDATE_DO)
2689                 return nft_table_validate(net, table);
2690
2691         return 0;
2692 err2:
2693         nf_tables_rule_release(&ctx, rule);
2694 err1:
2695         for (i = 0; i < n; i++) {
2696                 if (info[i].ops != NULL)
2697                         module_put(info[i].ops->type->owner);
2698         }
2699         kvfree(info);
2700         return err;
2701 }
2702
2703 static struct nft_rule *nft_rule_lookup_byid(const struct net *net,
2704                                              const struct nlattr *nla)
2705 {
2706         u32 id = ntohl(nla_get_be32(nla));
2707         struct nft_trans *trans;
2708
2709         list_for_each_entry(trans, &net->nft.commit_list, list) {
2710                 struct nft_rule *rule = nft_trans_rule(trans);
2711
2712                 if (trans->msg_type == NFT_MSG_NEWRULE &&
2713                     id == nft_trans_rule_id(trans))
2714                         return rule;
2715         }
2716         return ERR_PTR(-ENOENT);
2717 }
2718
2719 static int nf_tables_delrule(struct net *net, struct sock *nlsk,
2720                              struct sk_buff *skb, const struct nlmsghdr *nlh,
2721                              const struct nlattr * const nla[],
2722                              struct netlink_ext_ack *extack)
2723 {
2724         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2725         u8 genmask = nft_genmask_next(net);
2726         struct nft_table *table;
2727         struct nft_chain *chain = NULL;
2728         struct nft_rule *rule;
2729         int family = nfmsg->nfgen_family, err = 0;
2730         struct nft_ctx ctx;
2731
2732         table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask);
2733         if (IS_ERR(table)) {
2734                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_TABLE]);
2735                 return PTR_ERR(table);
2736         }
2737
2738         if (nla[NFTA_RULE_CHAIN]) {
2739                 chain = nft_chain_lookup(net, table, nla[NFTA_RULE_CHAIN],
2740                                          genmask);
2741                 if (IS_ERR(chain)) {
2742                         NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_CHAIN]);
2743                         return PTR_ERR(chain);
2744                 }
2745         }
2746
2747         nft_ctx_init(&ctx, net, skb, nlh, family, table, chain, nla);
2748
2749         if (chain) {
2750                 if (nla[NFTA_RULE_HANDLE]) {
2751                         rule = nft_rule_lookup(chain, nla[NFTA_RULE_HANDLE]);
2752                         if (IS_ERR(rule)) {
2753                                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_HANDLE]);
2754                                 return PTR_ERR(rule);
2755                         }
2756
2757                         err = nft_delrule(&ctx, rule);
2758                 } else if (nla[NFTA_RULE_ID]) {
2759                         rule = nft_rule_lookup_byid(net, nla[NFTA_RULE_ID]);
2760                         if (IS_ERR(rule)) {
2761                                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_ID]);
2762                                 return PTR_ERR(rule);
2763                         }
2764
2765                         err = nft_delrule(&ctx, rule);
2766                 } else {
2767                         err = nft_delrule_by_chain(&ctx);
2768                 }
2769         } else {
2770                 list_for_each_entry(chain, &table->chains, list) {
2771                         if (!nft_is_active_next(net, chain))
2772                                 continue;
2773
2774                         ctx.chain = chain;
2775                         err = nft_delrule_by_chain(&ctx);
2776                         if (err < 0)
2777                                 break;
2778                 }
2779         }
2780
2781         return err;
2782 }
2783
2784 /*
2785  * Sets
2786  */
2787
2788 static LIST_HEAD(nf_tables_set_types);
2789
2790 int nft_register_set(struct nft_set_type *type)
2791 {
2792         nfnl_lock(NFNL_SUBSYS_NFTABLES);
2793         list_add_tail_rcu(&type->list, &nf_tables_set_types);
2794         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
2795         return 0;
2796 }
2797 EXPORT_SYMBOL_GPL(nft_register_set);
2798
2799 void nft_unregister_set(struct nft_set_type *type)
2800 {
2801         nfnl_lock(NFNL_SUBSYS_NFTABLES);
2802         list_del_rcu(&type->list);
2803         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
2804 }
2805 EXPORT_SYMBOL_GPL(nft_unregister_set);
2806
2807 #define NFT_SET_FEATURES        (NFT_SET_INTERVAL | NFT_SET_MAP | \
2808                                  NFT_SET_TIMEOUT | NFT_SET_OBJECT | \
2809                                  NFT_SET_EVAL)
2810
2811 static bool nft_set_ops_candidate(const struct nft_set_type *type, u32 flags)
2812 {
2813         return (flags & type->features) == (flags & NFT_SET_FEATURES);
2814 }
2815
2816 /*
2817  * Select a set implementation based on the data characteristics and the
2818  * given policy. The total memory use might not be known if no size is
2819  * given, in that case the amount of memory per element is used.
2820  */
2821 static const struct nft_set_ops *
2822 nft_select_set_ops(const struct nft_ctx *ctx,
2823                    const struct nlattr * const nla[],
2824                    const struct nft_set_desc *desc,
2825                    enum nft_set_policies policy)
2826 {
2827         const struct nft_set_ops *ops, *bops;
2828         struct nft_set_estimate est, best;
2829         const struct nft_set_type *type;
2830         u32 flags = 0;
2831
2832         lockdep_assert_held(&ctx->net->nft.commit_mutex);
2833         lockdep_nfnl_nft_mutex_not_held();
2834 #ifdef CONFIG_MODULES
2835         if (list_empty(&nf_tables_set_types)) {
2836                 nft_request_module(ctx->net, "nft-set");
2837                 if (!list_empty(&nf_tables_set_types))
2838                         return ERR_PTR(-EAGAIN);
2839         }
2840 #endif
2841         if (nla[NFTA_SET_FLAGS] != NULL)
2842                 flags = ntohl(nla_get_be32(nla[NFTA_SET_FLAGS]));
2843
2844         bops        = NULL;
2845         best.size   = ~0;
2846         best.lookup = ~0;
2847         best.space  = ~0;
2848
2849         list_for_each_entry(type, &nf_tables_set_types, list) {
2850                 ops = &type->ops;
2851
2852                 if (!nft_set_ops_candidate(type, flags))
2853                         continue;
2854                 if (!ops->estimate(desc, flags, &est))
2855                         continue;
2856
2857                 switch (policy) {
2858                 case NFT_SET_POL_PERFORMANCE:
2859                         if (est.lookup < best.lookup)
2860                                 break;
2861                         if (est.lookup == best.lookup &&
2862                             est.space < best.space)
2863                                 break;
2864                         continue;
2865                 case NFT_SET_POL_MEMORY:
2866                         if (!desc->size) {
2867                                 if (est.space < best.space)
2868                                         break;
2869                                 if (est.space == best.space &&
2870                                     est.lookup < best.lookup)
2871                                         break;
2872                         } else if (est.size < best.size || !bops) {
2873                                 break;
2874                         }
2875                         continue;
2876                 default:
2877                         break;
2878                 }
2879
2880                 if (!try_module_get(type->owner))
2881                         continue;
2882                 if (bops != NULL)
2883                         module_put(to_set_type(bops)->owner);
2884
2885                 bops = ops;
2886                 best = est;
2887         }
2888
2889         if (bops != NULL)
2890                 return bops;
2891
2892         return ERR_PTR(-EOPNOTSUPP);
2893 }
2894
2895 static const struct nla_policy nft_set_policy[NFTA_SET_MAX + 1] = {
2896         [NFTA_SET_TABLE]                = { .type = NLA_STRING,
2897                                             .len = NFT_TABLE_MAXNAMELEN - 1 },
2898         [NFTA_SET_NAME]                 = { .type = NLA_STRING,
2899                                             .len = NFT_SET_MAXNAMELEN - 1 },
2900         [NFTA_SET_FLAGS]                = { .type = NLA_U32 },
2901         [NFTA_SET_KEY_TYPE]             = { .type = NLA_U32 },
2902         [NFTA_SET_KEY_LEN]              = { .type = NLA_U32 },
2903         [NFTA_SET_DATA_TYPE]            = { .type = NLA_U32 },
2904         [NFTA_SET_DATA_LEN]             = { .type = NLA_U32 },
2905         [NFTA_SET_POLICY]               = { .type = NLA_U32 },
2906         [NFTA_SET_DESC]                 = { .type = NLA_NESTED },
2907         [NFTA_SET_ID]                   = { .type = NLA_U32 },
2908         [NFTA_SET_TIMEOUT]              = { .type = NLA_U64 },
2909         [NFTA_SET_GC_INTERVAL]          = { .type = NLA_U32 },
2910         [NFTA_SET_USERDATA]             = { .type = NLA_BINARY,
2911                                             .len  = NFT_USERDATA_MAXLEN },
2912         [NFTA_SET_OBJ_TYPE]             = { .type = NLA_U32 },
2913         [NFTA_SET_HANDLE]               = { .type = NLA_U64 },
2914 };
2915
2916 static const struct nla_policy nft_set_desc_policy[NFTA_SET_DESC_MAX + 1] = {
2917         [NFTA_SET_DESC_SIZE]            = { .type = NLA_U32 },
2918 };
2919
2920 static int nft_ctx_init_from_setattr(struct nft_ctx *ctx, struct net *net,
2921                                      const struct sk_buff *skb,
2922                                      const struct nlmsghdr *nlh,
2923                                      const struct nlattr * const nla[],
2924                                      struct netlink_ext_ack *extack,
2925                                      u8 genmask)
2926 {
2927         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2928         int family = nfmsg->nfgen_family;
2929         struct nft_table *table = NULL;
2930
2931         if (nla[NFTA_SET_TABLE] != NULL) {
2932                 table = nft_table_lookup(net, nla[NFTA_SET_TABLE], family,
2933                                          genmask);
2934                 if (IS_ERR(table)) {
2935                         NL_SET_BAD_ATTR(extack, nla[NFTA_SET_TABLE]);
2936                         return PTR_ERR(table);
2937                 }
2938         }
2939
2940         nft_ctx_init(ctx, net, skb, nlh, family, table, NULL, nla);
2941         return 0;
2942 }
2943
2944 static struct nft_set *nft_set_lookup(const struct nft_table *table,
2945                                       const struct nlattr *nla, u8 genmask)
2946 {
2947         struct nft_set *set;
2948
2949         if (nla == NULL)
2950                 return ERR_PTR(-EINVAL);
2951
2952         list_for_each_entry_rcu(set, &table->sets, list) {
2953                 if (!nla_strcmp(nla, set->name) &&
2954                     nft_active_genmask(set, genmask))
2955                         return set;
2956         }
2957         return ERR_PTR(-ENOENT);
2958 }
2959
2960 static struct nft_set *nft_set_lookup_byhandle(const struct nft_table *table,
2961                                                const struct nlattr *nla,
2962                                                u8 genmask)
2963 {
2964         struct nft_set *set;
2965
2966         list_for_each_entry(set, &table->sets, list) {
2967                 if (be64_to_cpu(nla_get_be64(nla)) == set->handle &&
2968                     nft_active_genmask(set, genmask))
2969                         return set;
2970         }
2971         return ERR_PTR(-ENOENT);
2972 }
2973
2974 static struct nft_set *nft_set_lookup_byid(const struct net *net,
2975                                            const struct nlattr *nla, u8 genmask)
2976 {
2977         struct nft_trans *trans;
2978         u32 id = ntohl(nla_get_be32(nla));
2979
2980         list_for_each_entry(trans, &net->nft.commit_list, list) {
2981                 if (trans->msg_type == NFT_MSG_NEWSET) {
2982                         struct nft_set *set = nft_trans_set(trans);
2983
2984                         if (id == nft_trans_set_id(trans) &&
2985                             nft_active_genmask(set, genmask))
2986                                 return set;
2987                 }
2988         }
2989         return ERR_PTR(-ENOENT);
2990 }
2991
2992 struct nft_set *nft_set_lookup_global(const struct net *net,
2993                                       const struct nft_table *table,
2994                                       const struct nlattr *nla_set_name,
2995                                       const struct nlattr *nla_set_id,
2996                                       u8 genmask)
2997 {
2998         struct nft_set *set;
2999
3000         set = nft_set_lookup(table, nla_set_name, genmask);
3001         if (IS_ERR(set)) {
3002                 if (!nla_set_id)
3003                         return set;
3004
3005                 set = nft_set_lookup_byid(net, nla_set_id, genmask);
3006         }
3007         return set;
3008 }
3009 EXPORT_SYMBOL_GPL(nft_set_lookup_global);
3010
3011 static int nf_tables_set_alloc_name(struct nft_ctx *ctx, struct nft_set *set,
3012                                     const char *name)
3013 {
3014         const struct nft_set *i;
3015         const char *p;
3016         unsigned long *inuse;
3017         unsigned int n = 0, min = 0;
3018
3019         p = strchr(name, '%');
3020         if (p != NULL) {
3021                 if (p[1] != 'd' || strchr(p + 2, '%'))
3022                         return -EINVAL;
3023
3024                 inuse = (unsigned long *)get_zeroed_page(GFP_KERNEL);
3025                 if (inuse == NULL)
3026                         return -ENOMEM;
3027 cont:
3028                 list_for_each_entry(i, &ctx->table->sets, list) {
3029                         int tmp;
3030
3031                         if (!nft_is_active_next(ctx->net, set))
3032                                 continue;
3033                         if (!sscanf(i->name, name, &tmp))
3034                                 continue;
3035                         if (tmp < min || tmp >= min + BITS_PER_BYTE * PAGE_SIZE)
3036                                 continue;
3037
3038                         set_bit(tmp - min, inuse);
3039                 }
3040
3041                 n = find_first_zero_bit(inuse, BITS_PER_BYTE * PAGE_SIZE);
3042                 if (n >= BITS_PER_BYTE * PAGE_SIZE) {
3043                         min += BITS_PER_BYTE * PAGE_SIZE;
3044                         memset(inuse, 0, PAGE_SIZE);
3045                         goto cont;
3046                 }
3047                 free_page((unsigned long)inuse);
3048         }
3049
3050         set->name = kasprintf(GFP_KERNEL, name, min + n);
3051         if (!set->name)
3052                 return -ENOMEM;
3053
3054         list_for_each_entry(i, &ctx->table->sets, list) {
3055                 if (!nft_is_active_next(ctx->net, i))
3056                         continue;
3057                 if (!strcmp(set->name, i->name)) {
3058                         kfree(set->name);
3059                         return -ENFILE;
3060                 }
3061         }
3062         return 0;
3063 }
3064
3065 static int nf_msecs_to_jiffies64(const struct nlattr *nla, u64 *result)
3066 {
3067         u64 ms = be64_to_cpu(nla_get_be64(nla));
3068         u64 max = (u64)(~((u64)0));
3069
3070         max = div_u64(max, NSEC_PER_MSEC);
3071         if (ms >= max)
3072                 return -ERANGE;
3073
3074         ms *= NSEC_PER_MSEC;
3075         *result = nsecs_to_jiffies64(ms);
3076         return 0;
3077 }
3078
3079 static __be64 nf_jiffies64_to_msecs(u64 input)
3080 {
3081         u64 ms = jiffies64_to_nsecs(input);
3082
3083         return cpu_to_be64(div_u64(ms, NSEC_PER_MSEC));
3084 }
3085
3086 static int nf_tables_fill_set(struct sk_buff *skb, const struct nft_ctx *ctx,
3087                               const struct nft_set *set, u16 event, u16 flags)
3088 {
3089         struct nfgenmsg *nfmsg;
3090         struct nlmsghdr *nlh;
3091         struct nlattr *desc;
3092         u32 portid = ctx->portid;
3093         u32 seq = ctx->seq;
3094
3095         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
3096         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg),
3097                         flags);
3098         if (nlh == NULL)
3099                 goto nla_put_failure;
3100
3101         nfmsg = nlmsg_data(nlh);
3102         nfmsg->nfgen_family     = ctx->family;
3103         nfmsg->version          = NFNETLINK_V0;
3104         nfmsg->res_id           = htons(ctx->net->nft.base_seq & 0xffff);
3105
3106         if (nla_put_string(skb, NFTA_SET_TABLE, ctx->table->name))
3107                 goto nla_put_failure;
3108         if (nla_put_string(skb, NFTA_SET_NAME, set->name))
3109                 goto nla_put_failure;
3110         if (nla_put_be64(skb, NFTA_SET_HANDLE, cpu_to_be64(set->handle),
3111                          NFTA_SET_PAD))
3112                 goto nla_put_failure;
3113         if (set->flags != 0)
3114                 if (nla_put_be32(skb, NFTA_SET_FLAGS, htonl(set->flags)))
3115                         goto nla_put_failure;
3116
3117         if (nla_put_be32(skb, NFTA_SET_KEY_TYPE, htonl(set->ktype)))
3118                 goto nla_put_failure;
3119         if (nla_put_be32(skb, NFTA_SET_KEY_LEN, htonl(set->klen)))
3120                 goto nla_put_failure;
3121         if (set->flags & NFT_SET_MAP) {
3122                 if (nla_put_be32(skb, NFTA_SET_DATA_TYPE, htonl(set->dtype)))
3123                         goto nla_put_failure;
3124                 if (nla_put_be32(skb, NFTA_SET_DATA_LEN, htonl(set->dlen)))
3125                         goto nla_put_failure;
3126         }
3127         if (set->flags & NFT_SET_OBJECT &&
3128             nla_put_be32(skb, NFTA_SET_OBJ_TYPE, htonl(set->objtype)))
3129                 goto nla_put_failure;
3130
3131         if (set->timeout &&
3132             nla_put_be64(skb, NFTA_SET_TIMEOUT,
3133                          nf_jiffies64_to_msecs(set->timeout),
3134                          NFTA_SET_PAD))
3135                 goto nla_put_failure;
3136         if (set->gc_int &&
3137             nla_put_be32(skb, NFTA_SET_GC_INTERVAL, htonl(set->gc_int)))
3138                 goto nla_put_failure;
3139
3140         if (set->policy != NFT_SET_POL_PERFORMANCE) {
3141                 if (nla_put_be32(skb, NFTA_SET_POLICY, htonl(set->policy)))
3142                         goto nla_put_failure;
3143         }
3144
3145         if (nla_put(skb, NFTA_SET_USERDATA, set->udlen, set->udata))
3146                 goto nla_put_failure;
3147
3148         desc = nla_nest_start(skb, NFTA_SET_DESC);
3149         if (desc == NULL)
3150                 goto nla_put_failure;
3151         if (set->size &&
3152             nla_put_be32(skb, NFTA_SET_DESC_SIZE, htonl(set->size)))
3153                 goto nla_put_failure;
3154         nla_nest_end(skb, desc);
3155
3156         nlmsg_end(skb, nlh);
3157         return 0;
3158
3159 nla_put_failure:
3160         nlmsg_trim(skb, nlh);
3161         return -1;
3162 }
3163
3164 static void nf_tables_set_notify(const struct nft_ctx *ctx,
3165                                  const struct nft_set *set, int event,
3166                                  gfp_t gfp_flags)
3167 {
3168         struct sk_buff *skb;
3169         u32 portid = ctx->portid;
3170         int err;
3171
3172         if (!ctx->report &&
3173             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
3174                 return;
3175
3176         skb = nlmsg_new(NLMSG_GOODSIZE, gfp_flags);
3177         if (skb == NULL)
3178                 goto err;
3179
3180         err = nf_tables_fill_set(skb, ctx, set, event, 0);
3181         if (err < 0) {
3182                 kfree_skb(skb);
3183                 goto err;
3184         }
3185
3186         nfnetlink_send(skb, ctx->net, portid, NFNLGRP_NFTABLES, ctx->report,
3187                        gfp_flags);
3188         return;
3189 err:
3190         nfnetlink_set_err(ctx->net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
3191 }
3192
3193 static int nf_tables_dump_sets(struct sk_buff *skb, struct netlink_callback *cb)
3194 {
3195         const struct nft_set *set;
3196         unsigned int idx, s_idx = cb->args[0];
3197         struct nft_table *table, *cur_table = (struct nft_table *)cb->args[2];
3198         struct net *net = sock_net(skb->sk);
3199         struct nft_ctx *ctx = cb->data, ctx_set;
3200
3201         if (cb->args[1])
3202                 return skb->len;
3203
3204         rcu_read_lock();
3205         cb->seq = net->nft.base_seq;
3206
3207         list_for_each_entry_rcu(table, &net->nft.tables, list) {
3208                 if (ctx->family != NFPROTO_UNSPEC &&
3209                     ctx->family != table->family)
3210                         continue;
3211
3212                 if (ctx->table && ctx->table != table)
3213                         continue;
3214
3215                 if (cur_table) {
3216                         if (cur_table != table)
3217                                 continue;
3218
3219                         cur_table = NULL;
3220                 }
3221                 idx = 0;
3222                 list_for_each_entry_rcu(set, &table->sets, list) {
3223                         if (idx < s_idx)
3224                                 goto cont;
3225                         if (!nft_is_active(net, set))
3226                                 goto cont;
3227
3228                         ctx_set = *ctx;
3229                         ctx_set.table = table;
3230                         ctx_set.family = table->family;
3231
3232                         if (nf_tables_fill_set(skb, &ctx_set, set,
3233                                                NFT_MSG_NEWSET,
3234                                                NLM_F_MULTI) < 0) {
3235                                 cb->args[0] = idx;
3236                                 cb->args[2] = (unsigned long) table;
3237                                 goto done;
3238                         }
3239                         nl_dump_check_consistent(cb, nlmsg_hdr(skb));
3240 cont:
3241                         idx++;
3242                 }
3243                 if (s_idx)
3244                         s_idx = 0;
3245         }
3246         cb->args[1] = 1;
3247 done:
3248         rcu_read_unlock();
3249         return skb->len;
3250 }
3251
3252 static int nf_tables_dump_sets_start(struct netlink_callback *cb)
3253 {
3254         struct nft_ctx *ctx_dump = NULL;
3255
3256         ctx_dump = kmemdup(cb->data, sizeof(*ctx_dump), GFP_ATOMIC);
3257         if (ctx_dump == NULL)
3258                 return -ENOMEM;
3259
3260         cb->data = ctx_dump;
3261         return 0;
3262 }
3263
3264 static int nf_tables_dump_sets_done(struct netlink_callback *cb)
3265 {
3266         kfree(cb->data);
3267         return 0;
3268 }
3269
3270 /* called with rcu_read_lock held */
3271 static int nf_tables_getset(struct net *net, struct sock *nlsk,
3272                             struct sk_buff *skb, const struct nlmsghdr *nlh,
3273                             const struct nlattr * const nla[],
3274                             struct netlink_ext_ack *extack)
3275 {
3276         u8 genmask = nft_genmask_cur(net);
3277         const struct nft_set *set;
3278         struct nft_ctx ctx;
3279         struct sk_buff *skb2;
3280         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
3281         int err;
3282
3283         /* Verify existence before starting dump */
3284         err = nft_ctx_init_from_setattr(&ctx, net, skb, nlh, nla, extack,
3285                                         genmask);
3286         if (err < 0)
3287                 return err;
3288
3289         if (nlh->nlmsg_flags & NLM_F_DUMP) {
3290                 struct netlink_dump_control c = {
3291                         .start = nf_tables_dump_sets_start,
3292                         .dump = nf_tables_dump_sets,
3293                         .done = nf_tables_dump_sets_done,
3294                         .data = &ctx,
3295                         .module = THIS_MODULE,
3296                 };
3297
3298                 return nft_netlink_dump_start_rcu(nlsk, skb, nlh, &c);
3299         }
3300
3301         /* Only accept unspec with dump */
3302         if (nfmsg->nfgen_family == NFPROTO_UNSPEC)
3303                 return -EAFNOSUPPORT;
3304         if (!nla[NFTA_SET_TABLE])
3305                 return -EINVAL;
3306
3307         set = nft_set_lookup(ctx.table, nla[NFTA_SET_NAME], genmask);
3308         if (IS_ERR(set))
3309                 return PTR_ERR(set);
3310
3311         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
3312         if (skb2 == NULL)
3313                 return -ENOMEM;
3314
3315         err = nf_tables_fill_set(skb2, &ctx, set, NFT_MSG_NEWSET, 0);
3316         if (err < 0)
3317                 goto err;
3318
3319         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
3320
3321 err:
3322         kfree_skb(skb2);
3323         return err;
3324 }
3325
3326 static int nf_tables_set_desc_parse(const struct nft_ctx *ctx,
3327                                     struct nft_set_desc *desc,
3328                                     const struct nlattr *nla)
3329 {
3330         struct nlattr *da[NFTA_SET_DESC_MAX + 1];
3331         int err;
3332
3333         err = nla_parse_nested(da, NFTA_SET_DESC_MAX, nla,
3334                                nft_set_desc_policy, NULL);
3335         if (err < 0)
3336                 return err;
3337