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