net/netfilter/nf_tables_api.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2007-2009 Patrick McHardy <kaber@trash.net>
   4  *
   5  * Development of this code funded by Astaro AG (http://www.astaro.com/)
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/init.h>
  10 #include <linux/list.h>
  11 #include <linux/skbuff.h>
  12 #include <linux/netlink.h>
  13 #include <linux/vmalloc.h>
  14 #include <linux/rhashtable.h>
  15 #include <linux/audit.h>
  16 #include <linux/netfilter.h>
  17 #include <linux/netfilter/nfnetlink.h>
  18 #include <linux/netfilter/nf_tables.h>
  19 #include <net/netfilter/nf_flow_table.h>
  20 #include <net/netfilter/nf_tables_core.h>
  21 #include <net/netfilter/nf_tables.h>
  22 #include <net/netfilter/nf_tables_offload.h>
  23 #include <net/net_namespace.h>
  24 #include <net/sock.h>
  25
  26 #define NFT_MODULE_AUTOLOAD_LIMIT (MODULE_NAME_LEN - sizeof("nft-expr-255-"))
  27
  28 unsigned int nf_tables_net_id __read_mostly;
  29
  30 static LIST_HEAD(nf_tables_expressions);
  31 static LIST_HEAD(nf_tables_objects);
  32 static LIST_HEAD(nf_tables_flowtables);
  33 static LIST_HEAD(nf_tables_destroy_list);
  34 static DEFINE_SPINLOCK(nf_tables_destroy_list_lock);
  35 static u64 table_handle;
  36
  37 enum {
  38         NFT_VALIDATE_SKIP       = 0,
  39         NFT_VALIDATE_NEED,
  40         NFT_VALIDATE_DO,
  41 };
  42
  43 static struct rhltable nft_objname_ht;
  44
  45 static u32 nft_chain_hash(const void *data, u32 len, u32 seed);
  46 static u32 nft_chain_hash_obj(const void *data, u32 len, u32 seed);
  47 static int nft_chain_hash_cmp(struct rhashtable_compare_arg *, const void *);
  48
  49 static u32 nft_objname_hash(const void *data, u32 len, u32 seed);
  50 static u32 nft_objname_hash_obj(const void *data, u32 len, u32 seed);
  51 static int nft_objname_hash_cmp(struct rhashtable_compare_arg *, const void *);
  52
  53 static const struct rhashtable_params nft_chain_ht_params = {
  54         .head_offset            = offsetof(struct nft_chain, rhlhead),
  55         .key_offset             = offsetof(struct nft_chain, name),
  56         .hashfn                 = nft_chain_hash,
  57         .obj_hashfn             = nft_chain_hash_obj,
  58         .obj_cmpfn              = nft_chain_hash_cmp,
  59         .automatic_shrinking    = true,
  60 };
  61
  62 static const struct rhashtable_params nft_objname_ht_params = {
  63         .head_offset            = offsetof(struct nft_object, rhlhead),
  64         .key_offset             = offsetof(struct nft_object, key),
  65         .hashfn                 = nft_objname_hash,
  66         .obj_hashfn             = nft_objname_hash_obj,
  67         .obj_cmpfn              = nft_objname_hash_cmp,
  68         .automatic_shrinking    = true,
  69 };
  70
  71 struct nft_audit_data {
  72         struct nft_table *table;
  73         int entries;
  74         int op;
  75         struct list_head list;
  76 };
  77
  78 static const u8 nft2audit_op[NFT_MSG_MAX] = { // enum nf_tables_msg_types
  79         [NFT_MSG_NEWTABLE]      = AUDIT_NFT_OP_TABLE_REGISTER,
  80         [NFT_MSG_GETTABLE]      = AUDIT_NFT_OP_INVALID,
  81         [NFT_MSG_DELTABLE]      = AUDIT_NFT_OP_TABLE_UNREGISTER,
  82         [NFT_MSG_NEWCHAIN]      = AUDIT_NFT_OP_CHAIN_REGISTER,
  83         [NFT_MSG_GETCHAIN]      = AUDIT_NFT_OP_INVALID,
  84         [NFT_MSG_DELCHAIN]      = AUDIT_NFT_OP_CHAIN_UNREGISTER,
  85         [NFT_MSG_NEWRULE]       = AUDIT_NFT_OP_RULE_REGISTER,
  86         [NFT_MSG_GETRULE]       = AUDIT_NFT_OP_INVALID,
  87         [NFT_MSG_DELRULE]       = AUDIT_NFT_OP_RULE_UNREGISTER,
  88         [NFT_MSG_NEWSET]        = AUDIT_NFT_OP_SET_REGISTER,
  89         [NFT_MSG_GETSET]        = AUDIT_NFT_OP_INVALID,
  90         [NFT_MSG_DELSET]        = AUDIT_NFT_OP_SET_UNREGISTER,
  91         [NFT_MSG_NEWSETELEM]    = AUDIT_NFT_OP_SETELEM_REGISTER,
  92         [NFT_MSG_GETSETELEM]    = AUDIT_NFT_OP_INVALID,
  93         [NFT_MSG_DELSETELEM]    = AUDIT_NFT_OP_SETELEM_UNREGISTER,
  94         [NFT_MSG_NEWGEN]        = AUDIT_NFT_OP_GEN_REGISTER,
  95         [NFT_MSG_GETGEN]        = AUDIT_NFT_OP_INVALID,
  96         [NFT_MSG_TRACE]         = AUDIT_NFT_OP_INVALID,
  97         [NFT_MSG_NEWOBJ]        = AUDIT_NFT_OP_OBJ_REGISTER,
  98         [NFT_MSG_GETOBJ]        = AUDIT_NFT_OP_INVALID,
  99         [NFT_MSG_DELOBJ]        = AUDIT_NFT_OP_OBJ_UNREGISTER,
 100         [NFT_MSG_GETOBJ_RESET]  = AUDIT_NFT_OP_OBJ_RESET,
 101         [NFT_MSG_NEWFLOWTABLE]  = AUDIT_NFT_OP_FLOWTABLE_REGISTER,
 102         [NFT_MSG_GETFLOWTABLE]  = AUDIT_NFT_OP_INVALID,
 103         [NFT_MSG_DELFLOWTABLE]  = AUDIT_NFT_OP_FLOWTABLE_UNREGISTER,
 104 };
 105
 106 static void nft_validate_state_update(struct net *net, u8 new_validate_state)
 107 {
 108         struct nftables_pernet *nft_net = nft_pernet(net);
 109
 110         switch (nft_net->validate_state) {
 111         case NFT_VALIDATE_SKIP:
 112                 WARN_ON_ONCE(new_validate_state == NFT_VALIDATE_DO);
 113                 break;
 114         case NFT_VALIDATE_NEED:
 115                 break;
 116         case NFT_VALIDATE_DO:
 117                 if (new_validate_state == NFT_VALIDATE_NEED)
 118                         return;
 119         }
 120
 121         nft_net->validate_state = new_validate_state;
 122 }
 123 static void nf_tables_trans_destroy_work(struct work_struct *w);
 124 static DECLARE_WORK(trans_destroy_work, nf_tables_trans_destroy_work);
 125
 126 static void nft_ctx_init(struct nft_ctx *ctx,
 127                          struct net *net,
 128                          const struct sk_buff *skb,
 129                          const struct nlmsghdr *nlh,
 130                          u8 family,
 131                          struct nft_table *table,
 132                          struct nft_chain *chain,
 133                          const struct nlattr * const *nla)
 134 {
 135         ctx->net        = net;
 136         ctx->family     = family;
 137         ctx->level      = 0;
 138         ctx->table      = table;
 139         ctx->chain      = chain;
 140         ctx->nla        = nla;
 141         ctx->portid     = NETLINK_CB(skb).portid;
 142         ctx->report     = nlmsg_report(nlh);
 143         ctx->flags      = nlh->nlmsg_flags;
 144         ctx->seq        = nlh->nlmsg_seq;
 145 }
 146
 147 static struct nft_trans *nft_trans_alloc_gfp(const struct nft_ctx *ctx,
 148                                              int msg_type, u32 size, gfp_t gfp)
 149 {
 150         struct nft_trans *trans;
 151
 152         trans = kzalloc(sizeof(struct nft_trans) + size, gfp);
 153         if (trans == NULL)
 154                 return NULL;
 155
 156         trans->msg_type = msg_type;
 157         trans->ctx      = *ctx;
 158
 159         return trans;
 160 }
 161
 162 static struct nft_trans *nft_trans_alloc(const struct nft_ctx *ctx,
 163                                          int msg_type, u32 size)
 164 {
 165         return nft_trans_alloc_gfp(ctx, msg_type, size, GFP_KERNEL);
 166 }
 167
 168 static void nft_trans_destroy(struct nft_trans *trans)
 169 {
 170         list_del(&trans->list);
 171         kfree(trans);
 172 }
 173
 174 static void nft_set_trans_bind(const struct nft_ctx *ctx, struct nft_set *set)
 175 {
 176         struct nftables_pernet *nft_net;
 177         struct net *net = ctx->net;
 178         struct nft_trans *trans;
 179
 180         if (!nft_set_is_anonymous(set))
 181                 return;
 182
 183         nft_net = nft_pernet(net);
 184         list_for_each_entry_reverse(trans, &nft_net->commit_list, list) {
 185                 switch (trans->msg_type) {
 186                 case NFT_MSG_NEWSET:
 187                         if (nft_trans_set(trans) == set)
 188                                 nft_trans_set_bound(trans) = true;
 189                         break;
 190                 case NFT_MSG_NEWSETELEM:
 191                         if (nft_trans_elem_set(trans) == set)
 192                                 nft_trans_elem_set_bound(trans) = true;
 193                         break;
 194                 }
 195         }
 196 }
 197
 198 static int nft_netdev_register_hooks(struct net *net,
 199                                      struct list_head *hook_list)
 200 {
 201         struct nft_hook *hook;
 202         int err, j;
 203
 204         j = 0;
 205         list_for_each_entry(hook, hook_list, list) {
 206                 err = nf_register_net_hook(net, &hook->ops);
 207                 if (err < 0)
 208                         goto err_register;
 209
 210                 j++;
 211         }
 212         return 0;
 213
 214 err_register:
 215         list_for_each_entry(hook, hook_list, list) {
 216                 if (j-- <= 0)
 217                         break;
 218
 219                 nf_unregister_net_hook(net, &hook->ops);
 220         }
 221         return err;
 222 }
 223
 224 static void nft_netdev_unregister_hooks(struct net *net,
 225                                         struct list_head *hook_list)
 226 {
 227         struct nft_hook *hook;
 228
 229         list_for_each_entry(hook, hook_list, list)
 230                 nf_unregister_net_hook(net, &hook->ops);
 231 }
 232
 233 static int nf_tables_register_hook(struct net *net,
 234                                    const struct nft_table *table,
 235                                    struct nft_chain *chain)
 236 {
 237         struct nft_base_chain *basechain;
 238         const struct nf_hook_ops *ops;
 239
 240         if (table->flags & NFT_TABLE_F_DORMANT ||
 241             !nft_is_base_chain(chain))
 242                 return 0;
 243
 244         basechain = nft_base_chain(chain);
 245         ops = &basechain->ops;
 246
 247         if (basechain->type->ops_register)
 248                 return basechain->type->ops_register(net, ops);
 249
 250         if (nft_base_chain_netdev(table->family, basechain->ops.hooknum))
 251                 return nft_netdev_register_hooks(net, &basechain->hook_list);
 252
 253         return nf_register_net_hook(net, &basechain->ops);
 254 }
 255
 256 static void nf_tables_unregister_hook(struct net *net,
 257                                       const struct nft_table *table,
 258                                       struct nft_chain *chain)
 259 {
 260         struct nft_base_chain *basechain;
 261         const struct nf_hook_ops *ops;
 262
 263         if (table->flags & NFT_TABLE_F_DORMANT ||
 264             !nft_is_base_chain(chain))
 265                 return;
 266         basechain = nft_base_chain(chain);
 267         ops = &basechain->ops;
 268
 269         if (basechain->type->ops_unregister)
 270                 return basechain->type->ops_unregister(net, ops);
 271
 272         if (nft_base_chain_netdev(table->family, basechain->ops.hooknum))
 273                 nft_netdev_unregister_hooks(net, &basechain->hook_list);
 274         else
 275                 nf_unregister_net_hook(net, &basechain->ops);
 276 }
 277
 278 static void nft_trans_commit_list_add_tail(struct net *net, struct nft_trans *trans)
 279 {
 280         struct nftables_pernet *nft_net = nft_pernet(net);
 281
 282         list_add_tail(&trans->list, &nft_net->commit_list);
 283 }
 284
 285 static int nft_trans_table_add(struct nft_ctx *ctx, int msg_type)
 286 {
 287         struct nft_trans *trans;
 288
 289         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_table));
 290         if (trans == NULL)
 291                 return -ENOMEM;
 292
 293         if (msg_type == NFT_MSG_NEWTABLE)
 294                 nft_activate_next(ctx->net, ctx->table);
 295
 296         nft_trans_commit_list_add_tail(ctx->net, trans);
 297         return 0;
 298 }
 299
 300 static int nft_deltable(struct nft_ctx *ctx)
 301 {
 302         int err;
 303
 304         err = nft_trans_table_add(ctx, NFT_MSG_DELTABLE);
 305         if (err < 0)
 306                 return err;
 307
 308         nft_deactivate_next(ctx->net, ctx->table);
 309         return err;
 310 }
 311
 312 static struct nft_trans *nft_trans_chain_add(struct nft_ctx *ctx, int msg_type)
 313 {
 314         struct nft_trans *trans;
 315
 316         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_chain));
 317         if (trans == NULL)
 318                 return ERR_PTR(-ENOMEM);
 319
 320         if (msg_type == NFT_MSG_NEWCHAIN) {
 321                 nft_activate_next(ctx->net, ctx->chain);
 322
 323                 if (ctx->nla[NFTA_CHAIN_ID]) {
 324                         nft_trans_chain_id(trans) =
 325                                 ntohl(nla_get_be32(ctx->nla[NFTA_CHAIN_ID]));
 326                 }
 327         }
 328
 329         nft_trans_commit_list_add_tail(ctx->net, trans);
 330         return trans;
 331 }
 332
 333 static int nft_delchain(struct nft_ctx *ctx)
 334 {
 335         struct nft_trans *trans;
 336
 337         trans = nft_trans_chain_add(ctx, NFT_MSG_DELCHAIN);
 338         if (IS_ERR(trans))
 339                 return PTR_ERR(trans);
 340
 341         ctx->table->use--;
 342         nft_deactivate_next(ctx->net, ctx->chain);
 343
 344         return 0;
 345 }
 346
 347 static void nft_rule_expr_activate(const struct nft_ctx *ctx,
 348                                    struct nft_rule *rule)
 349 {
 350         struct nft_expr *expr;
 351
 352         expr = nft_expr_first(rule);
 353         while (nft_expr_more(rule, expr)) {
 354                 if (expr->ops->activate)
 355                         expr->ops->activate(ctx, expr);
 356
 357                 expr = nft_expr_next(expr);
 358         }
 359 }
 360
 361 static void nft_rule_expr_deactivate(const struct nft_ctx *ctx,
 362                                      struct nft_rule *rule,
 363                                      enum nft_trans_phase phase)
 364 {
 365         struct nft_expr *expr;
 366
 367         expr = nft_expr_first(rule);
 368         while (nft_expr_more(rule, expr)) {
 369                 if (expr->ops->deactivate)
 370                         expr->ops->deactivate(ctx, expr, phase);
 371
 372                 expr = nft_expr_next(expr);
 373         }
 374 }
 375
 376 static int
 377 nf_tables_delrule_deactivate(struct nft_ctx *ctx, struct nft_rule *rule)
 378 {
 379         /* You cannot delete the same rule twice */
 380         if (nft_is_active_next(ctx->net, rule)) {
 381                 nft_deactivate_next(ctx->net, rule);
 382                 ctx->chain->use--;
 383                 return 0;
 384         }
 385         return -ENOENT;
 386 }
 387
 388 static struct nft_trans *nft_trans_rule_add(struct nft_ctx *ctx, int msg_type,
 389                                             struct nft_rule *rule)
 390 {
 391         struct nft_trans *trans;
 392
 393         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_rule));
 394         if (trans == NULL)
 395                 return NULL;
 396
 397         if (msg_type == NFT_MSG_NEWRULE && ctx->nla[NFTA_RULE_ID] != NULL) {
 398                 nft_trans_rule_id(trans) =
 399                         ntohl(nla_get_be32(ctx->nla[NFTA_RULE_ID]));
 400         }
 401         nft_trans_rule(trans) = rule;
 402         nft_trans_commit_list_add_tail(ctx->net, trans);
 403
 404         return trans;
 405 }
 406
 407 static int nft_delrule(struct nft_ctx *ctx, struct nft_rule *rule)
 408 {
 409         struct nft_flow_rule *flow;
 410         struct nft_trans *trans;
 411         int err;
 412
 413         trans = nft_trans_rule_add(ctx, NFT_MSG_DELRULE, rule);
 414         if (trans == NULL)
 415                 return -ENOMEM;
 416
 417         if (ctx->chain->flags & NFT_CHAIN_HW_OFFLOAD) {
 418                 flow = nft_flow_rule_create(ctx->net, rule);
 419                 if (IS_ERR(flow)) {
 420                         nft_trans_destroy(trans);
 421                         return PTR_ERR(flow);
 422                 }
 423
 424                 nft_trans_flow_rule(trans) = flow;
 425         }
 426
 427         err = nf_tables_delrule_deactivate(ctx, rule);
 428         if (err < 0) {
 429                 nft_trans_destroy(trans);
 430                 return err;
 431         }
 432         nft_rule_expr_deactivate(ctx, rule, NFT_TRANS_PREPARE);
 433
 434         return 0;
 435 }
 436
 437 static int nft_delrule_by_chain(struct nft_ctx *ctx)
 438 {
 439         struct nft_rule *rule;
 440         int err;
 441
 442         list_for_each_entry(rule, &ctx->chain->rules, list) {
 443                 if (!nft_is_active_next(ctx->net, rule))
 444                         continue;
 445
 446                 err = nft_delrule(ctx, rule);
 447                 if (err < 0)
 448                         return err;
 449         }
 450         return 0;
 451 }
 452
 453 static int nft_trans_set_add(const struct nft_ctx *ctx, int msg_type,
 454                              struct nft_set *set)
 455 {
 456         struct nft_trans *trans;
 457
 458         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_set));
 459         if (trans == NULL)
 460                 return -ENOMEM;
 461
 462         if (msg_type == NFT_MSG_NEWSET && ctx->nla[NFTA_SET_ID] != NULL) {
 463                 nft_trans_set_id(trans) =
 464                         ntohl(nla_get_be32(ctx->nla[NFTA_SET_ID]));
 465                 nft_activate_next(ctx->net, set);
 466         }
 467         nft_trans_set(trans) = set;
 468         nft_trans_commit_list_add_tail(ctx->net, trans);
 469
 470         return 0;
 471 }
 472
 473 static int nft_delset(const struct nft_ctx *ctx, struct nft_set *set)
 474 {
 475         int err;
 476
 477         err = nft_trans_set_add(ctx, NFT_MSG_DELSET, set);
 478         if (err < 0)
 479                 return err;
 480
 481         nft_deactivate_next(ctx->net, set);
 482         ctx->table->use--;
 483
 484         return err;
 485 }
 486
 487 static int nft_trans_obj_add(struct nft_ctx *ctx, int msg_type,
 488                              struct nft_object *obj)
 489 {
 490         struct nft_trans *trans;
 491
 492         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_obj));
 493         if (trans == NULL)
 494                 return -ENOMEM;
 495
 496         if (msg_type == NFT_MSG_NEWOBJ)
 497                 nft_activate_next(ctx->net, obj);
 498
 499         nft_trans_obj(trans) = obj;
 500         nft_trans_commit_list_add_tail(ctx->net, trans);
 501
 502         return 0;
 503 }
 504
 505 static int nft_delobj(struct nft_ctx *ctx, struct nft_object *obj)
 506 {
 507         int err;
 508
 509         err = nft_trans_obj_add(ctx, NFT_MSG_DELOBJ, obj);
 510         if (err < 0)
 511                 return err;
 512
 513         nft_deactivate_next(ctx->net, obj);
 514         ctx->table->use--;
 515
 516         return err;
 517 }
 518
 519 static int nft_trans_flowtable_add(struct nft_ctx *ctx, int msg_type,
 520                                    struct nft_flowtable *flowtable)
 521 {
 522         struct nft_trans *trans;
 523
 524         trans = nft_trans_alloc(ctx, msg_type,
 525                                 sizeof(struct nft_trans_flowtable));
 526         if (trans == NULL)
 527                 return -ENOMEM;
 528
 529         if (msg_type == NFT_MSG_NEWFLOWTABLE)
 530                 nft_activate_next(ctx->net, flowtable);
 531
 532         nft_trans_flowtable(trans) = flowtable;
 533         nft_trans_commit_list_add_tail(ctx->net, trans);
 534
 535         return 0;
 536 }
 537
 538 static int nft_delflowtable(struct nft_ctx *ctx,
 539                             struct nft_flowtable *flowtable)
 540 {
 541         int err;
 542
 543         err = nft_trans_flowtable_add(ctx, NFT_MSG_DELFLOWTABLE, flowtable);
 544         if (err < 0)
 545                 return err;
 546
 547         nft_deactivate_next(ctx->net, flowtable);
 548         ctx->table->use--;
 549
 550         return err;
 551 }
 552
 553 /*
 554  * Tables
 555  */
 556
 557 static struct nft_table *nft_table_lookup(const struct net *net,
 558                                           const struct nlattr *nla,
 559                                           u8 family, u8 genmask, u32 nlpid)
 560 {
 561         struct nftables_pernet *nft_net;
 562         struct nft_table *table;
 563
 564         if (nla == NULL)
 565                 return ERR_PTR(-EINVAL);
 566
 567         nft_net = nft_pernet(net);
 568         list_for_each_entry_rcu(table, &nft_net->tables, list,
 569                                 lockdep_is_held(&nft_net->commit_mutex)) {
 570                 if (!nla_strcmp(nla, table->name) &&
 571                     table->family == family &&
 572                     nft_active_genmask(table, genmask)) {
 573                         if (nft_table_has_owner(table) &&
 574                             nlpid && table->nlpid != nlpid)
 575                                 return ERR_PTR(-EPERM);
 576
 577                         return table;
 578                 }
 579         }
 580
 581         return ERR_PTR(-ENOENT);
 582 }
 583
 584 static struct nft_table *nft_table_lookup_byhandle(const struct net *net,
 585                                                    const struct nlattr *nla,
 586                                                    u8 genmask, u32 nlpid)
 587 {
 588         struct nftables_pernet *nft_net;
 589         struct nft_table *table;
 590
 591         nft_net = nft_pernet(net);
 592         list_for_each_entry(table, &nft_net->tables, list) {
 593                 if (be64_to_cpu(nla_get_be64(nla)) == table->handle &&
 594                     nft_active_genmask(table, genmask)) {
 595                         if (nft_table_has_owner(table) &&
 596                             nlpid && table->nlpid != nlpid)
 597                                 return ERR_PTR(-EPERM);
 598
 599                         return table;
 600                 }
 601         }
 602
 603         return ERR_PTR(-ENOENT);
 604 }
 605
 606 static inline u64 nf_tables_alloc_handle(struct nft_table *table)
 607 {
 608         return ++table->hgenerator;
 609 }
 610
 611 static const struct nft_chain_type *chain_type[NFPROTO_NUMPROTO][NFT_CHAIN_T_MAX];
 612
 613 static const struct nft_chain_type *
 614 __nft_chain_type_get(u8 family, enum nft_chain_types type)
 615 {
 616         if (family >= NFPROTO_NUMPROTO ||
 617             type >= NFT_CHAIN_T_MAX)
 618                 return NULL;
 619
 620         return chain_type[family][type];
 621 }
 622
 623 static const struct nft_chain_type *
 624 __nf_tables_chain_type_lookup(const struct nlattr *nla, u8 family)
 625 {
 626         const struct nft_chain_type *type;
 627         int i;
 628
 629         for (i = 0; i < NFT_CHAIN_T_MAX; i++) {
 630                 type = __nft_chain_type_get(family, i);
 631                 if (!type)
 632                         continue;
 633                 if (!nla_strcmp(nla, type->name))
 634                         return type;
 635         }
 636         return NULL;
 637 }
 638
 639 struct nft_module_request {
 640         struct list_head        list;
 641         char                    module[MODULE_NAME_LEN];
 642         bool                    done;
 643 };
 644
 645 #ifdef CONFIG_MODULES
 646 __printf(2, 3) int nft_request_module(struct net *net, const char *fmt,
 647                                       ...)
 648 {
 649         char module_name[MODULE_NAME_LEN];
 650         struct nftables_pernet *nft_net;
 651         struct nft_module_request *req;
 652         va_list args;
 653         int ret;
 654
 655         va_start(args, fmt);
 656         ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args);
 657         va_end(args);
 658         if (ret >= MODULE_NAME_LEN)
 659                 return 0;
 660
 661         nft_net = nft_pernet(net);
 662         list_for_each_entry(req, &nft_net->module_list, list) {
 663                 if (!strcmp(req->module, module_name)) {
 664                         if (req->done)
 665                                 return 0;
 666
 667                         /* A request to load this module already exists. */
 668                         return -EAGAIN;
 669                 }
 670         }
 671
 672         req = kmalloc(sizeof(*req), GFP_KERNEL);
 673         if (!req)
 674                 return -ENOMEM;
 675
 676         req->done = false;
 677         strlcpy(req->module, module_name, MODULE_NAME_LEN);
 678         list_add_tail(&req->list, &nft_net->module_list);
 679
 680         return -EAGAIN;
 681 }
 682 EXPORT_SYMBOL_GPL(nft_request_module);
 683 #endif
 684
 685 static void lockdep_nfnl_nft_mutex_not_held(void)
 686 {
 687 #ifdef CONFIG_PROVE_LOCKING
 688         if (debug_locks)
 689                 WARN_ON_ONCE(lockdep_nfnl_is_held(NFNL_SUBSYS_NFTABLES));
 690 #endif
 691 }
 692
 693 static const struct nft_chain_type *
 694 nf_tables_chain_type_lookup(struct net *net, const struct nlattr *nla,
 695                             u8 family, bool autoload)
 696 {
 697         const struct nft_chain_type *type;
 698
 699         type = __nf_tables_chain_type_lookup(nla, family);
 700         if (type != NULL)
 701                 return type;
 702
 703         lockdep_nfnl_nft_mutex_not_held();
 704 #ifdef CONFIG_MODULES
 705         if (autoload) {
 706                 if (nft_request_module(net, "nft-chain-%u-%.*s", family,
 707                                        nla_len(nla),
 708                                        (const char *)nla_data(nla)) == -EAGAIN)
 709                         return ERR_PTR(-EAGAIN);
 710         }
 711 #endif
 712         return ERR_PTR(-ENOENT);
 713 }
 714
 715 static __be16 nft_base_seq(const struct net *net)
 716 {
 717         struct nftables_pernet *nft_net = nft_pernet(net);
 718
 719         return htons(nft_net->base_seq & 0xffff);
 720 }
 721
 722 static const struct nla_policy nft_table_policy[NFTA_TABLE_MAX + 1] = {
 723         [NFTA_TABLE_NAME]       = { .type = NLA_STRING,
 724                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
 725         [NFTA_TABLE_FLAGS]      = { .type = NLA_U32 },
 726         [NFTA_TABLE_HANDLE]     = { .type = NLA_U64 },
 727         [NFTA_TABLE_USERDATA]   = { .type = NLA_BINARY,
 728                                     .len = NFT_USERDATA_MAXLEN }
 729 };
 730
 731 static int nf_tables_fill_table_info(struct sk_buff *skb, struct net *net,
 732                                      u32 portid, u32 seq, int event, u32 flags,
 733                                      int family, const struct nft_table *table)
 734 {
 735         struct nlmsghdr *nlh;
 736
 737         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
 738         nlh = nfnl_msg_put(skb, portid, seq, event, flags, family,
 739                            NFNETLINK_V0, nft_base_seq(net));
 740         if (!nlh)
 741                 goto nla_put_failure;
 742
 743         if (nla_put_string(skb, NFTA_TABLE_NAME, table->name) ||
 744             nla_put_be32(skb, NFTA_TABLE_FLAGS,
 745                          htonl(table->flags & NFT_TABLE_F_MASK)) ||
 746             nla_put_be32(skb, NFTA_TABLE_USE, htonl(table->use)) ||
 747             nla_put_be64(skb, NFTA_TABLE_HANDLE, cpu_to_be64(table->handle),
 748                          NFTA_TABLE_PAD))
 749                 goto nla_put_failure;
 750         if (nft_table_has_owner(table) &&
 751             nla_put_be32(skb, NFTA_TABLE_OWNER, htonl(table->nlpid)))
 752                 goto nla_put_failure;
 753
 754         if (table->udata) {
 755                 if (nla_put(skb, NFTA_TABLE_USERDATA, table->udlen, table->udata))
 756                         goto nla_put_failure;
 757         }
 758
 759         nlmsg_end(skb, nlh);
 760         return 0;
 761
 762 nla_put_failure:
 763         nlmsg_trim(skb, nlh);
 764         return -1;
 765 }
 766
 767 struct nftnl_skb_parms {
 768         bool report;
 769 };
 770 #define NFT_CB(skb)     (*(struct nftnl_skb_parms*)&((skb)->cb))
 771
 772 static void nft_notify_enqueue(struct sk_buff *skb, bool report,
 773                                struct list_head *notify_list)
 774 {
 775         NFT_CB(skb).report = report;
 776         list_add_tail(&skb->list, notify_list);
 777 }
 778
 779 static void nf_tables_table_notify(const struct nft_ctx *ctx, int event)
 780 {
 781         struct nftables_pernet *nft_net;
 782         struct sk_buff *skb;
 783         int err;
 784
 785         if (!ctx->report &&
 786             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
 787                 return;
 788
 789         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 790         if (skb == NULL)
 791                 goto err;
 792
 793         err = nf_tables_fill_table_info(skb, ctx->net, ctx->portid, ctx->seq,
 794                                         event, 0, ctx->family, ctx->table);
 795         if (err < 0) {
 796                 kfree_skb(skb);
 797                 goto err;
 798         }
 799
 800         nft_net = nft_pernet(ctx->net);
 801         nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);
 802         return;
 803 err:
 804         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
 805 }
 806
 807 static int nf_tables_dump_tables(struct sk_buff *skb,
 808                                  struct netlink_callback *cb)
 809 {
 810         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
 811         struct nftables_pernet *nft_net;
 812         const struct nft_table *table;
 813         unsigned int idx = 0, s_idx = cb->args[0];
 814         struct net *net = sock_net(skb->sk);
 815         int family = nfmsg->nfgen_family;
 816
 817         rcu_read_lock();
 818         nft_net = nft_pernet(net);
 819         cb->seq = nft_net->base_seq;
 820
 821         list_for_each_entry_rcu(table, &nft_net->tables, list) {
 822                 if (family != NFPROTO_UNSPEC && family != table->family)
 823                         continue;
 824
 825                 if (idx < s_idx)
 826                         goto cont;
 827                 if (idx > s_idx)
 828                         memset(&cb->args[1], 0,
 829                                sizeof(cb->args) - sizeof(cb->args[0]));
 830                 if (!nft_is_active(net, table))
 831                         continue;
 832                 if (nf_tables_fill_table_info(skb, net,
 833                                               NETLINK_CB(cb->skb).portid,
 834                                               cb->nlh->nlmsg_seq,
 835                                               NFT_MSG_NEWTABLE, NLM_F_MULTI,
 836                                               table->family, table) < 0)
 837                         goto done;
 838
 839                 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
 840 cont:
 841                 idx++;
 842         }
 843 done:
 844         rcu_read_unlock();
 845         cb->args[0] = idx;
 846         return skb->len;
 847 }
 848
 849 static int nft_netlink_dump_start_rcu(struct sock *nlsk, struct sk_buff *skb,
 850                                       const struct nlmsghdr *nlh,
 851                                       struct netlink_dump_control *c)
 852 {
 853         int err;
 854
 855         if (!try_module_get(THIS_MODULE))
 856                 return -EINVAL;
 857
 858         rcu_read_unlock();
 859         err = netlink_dump_start(nlsk, skb, nlh, c);
 860         rcu_read_lock();
 861         module_put(THIS_MODULE);
 862
 863         return err;
 864 }
 865
 866 /* called with rcu_read_lock held */
 867 static int nf_tables_gettable(struct sk_buff *skb, const struct nfnl_info *info,
 868                               const struct nlattr * const nla[])
 869 {
 870         struct netlink_ext_ack *extack = info->extack;
 871         u8 genmask = nft_genmask_cur(info->net);
 872         u8 family = info->nfmsg->nfgen_family;
 873         const struct nft_table *table;
 874         struct net *net = info->net;
 875         struct sk_buff *skb2;
 876         int err;
 877
 878         if (info->nlh->nlmsg_flags & NLM_F_DUMP) {
 879                 struct netlink_dump_control c = {
 880                         .dump = nf_tables_dump_tables,
 881                         .module = THIS_MODULE,
 882                 };
 883
 884                 return nft_netlink_dump_start_rcu(info->sk, skb, info->nlh, &c);
 885         }
 886
 887         table = nft_table_lookup(net, nla[NFTA_TABLE_NAME], family, genmask, 0);
 888         if (IS_ERR(table)) {
 889                 NL_SET_BAD_ATTR(extack, nla[NFTA_TABLE_NAME]);
 890                 return PTR_ERR(table);
 891         }
 892
 893         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
 894         if (!skb2)
 895                 return -ENOMEM;
 896
 897         err = nf_tables_fill_table_info(skb2, net, NETLINK_CB(skb).portid,
 898                                         info->nlh->nlmsg_seq, NFT_MSG_NEWTABLE,
 899                                         0, family, table);
 900         if (err < 0)
 901                 goto err_fill_table_info;
 902
 903         return nfnetlink_unicast(skb2, net, NETLINK_CB(skb).portid);
 904
 905 err_fill_table_info:
 906         kfree_skb(skb2);
 907         return err;
 908 }
 909
 910 static void nft_table_disable(struct net *net, struct nft_table *table, u32 cnt)
 911 {
 912         struct nft_chain *chain;
 913         u32 i = 0;
 914
 915         list_for_each_entry(chain, &table->chains, list) {
 916                 if (!nft_is_active_next(net, chain))
 917                         continue;
 918                 if (!nft_is_base_chain(chain))
 919                         continue;
 920
 921                 if (cnt && i++ == cnt)
 922                         break;
 923
 924                 nf_tables_unregister_hook(net, table, chain);
 925         }
 926 }
 927
 928 static int nf_tables_table_enable(struct net *net, struct nft_table *table)
 929 {
 930         struct nft_chain *chain;
 931         int err, i = 0;
 932
 933         list_for_each_entry(chain, &table->chains, list) {
 934                 if (!nft_is_active_next(net, chain))
 935                         continue;
 936                 if (!nft_is_base_chain(chain))
 937                         continue;
 938
 939                 err = nf_tables_register_hook(net, table, chain);
 940                 if (err < 0)
 941                         goto err_register_hooks;
 942
 943                 i++;
 944         }
 945         return 0;
 946
 947 err_register_hooks:
 948         if (i)
 949                 nft_table_disable(net, table, i);
 950         return err;
 951 }
 952
 953 static void nf_tables_table_disable(struct net *net, struct nft_table *table)
 954 {
 955         table->flags &= ~NFT_TABLE_F_DORMANT;
 956         nft_table_disable(net, table, 0);
 957         table->flags |= NFT_TABLE_F_DORMANT;
 958 }
 959
 960 #define __NFT_TABLE_F_INTERNAL          (NFT_TABLE_F_MASK + 1)
 961 #define __NFT_TABLE_F_WAS_DORMANT       (__NFT_TABLE_F_INTERNAL << 0)
 962 #define __NFT_TABLE_F_WAS_AWAKEN        (__NFT_TABLE_F_INTERNAL << 1)
 963 #define __NFT_TABLE_F_UPDATE            (__NFT_TABLE_F_WAS_DORMANT | \
 964                                          __NFT_TABLE_F_WAS_AWAKEN)
 965
 966 static int nf_tables_updtable(struct nft_ctx *ctx)
 967 {
 968         struct nft_trans *trans;
 969         u32 flags;
 970         int ret;
 971
 972         if (!ctx->nla[NFTA_TABLE_FLAGS])
 973                 return 0;
 974
 975         flags = ntohl(nla_get_be32(ctx->nla[NFTA_TABLE_FLAGS]));
 976         if (flags & ~NFT_TABLE_F_MASK)
 977                 return -EOPNOTSUPP;
 978
 979         if (flags == ctx->table->flags)
 980                 return 0;
 981
 982         if ((nft_table_has_owner(ctx->table) &&
 983              !(flags & NFT_TABLE_F_OWNER)) ||
 984             (!nft_table_has_owner(ctx->table) &&
 985              flags & NFT_TABLE_F_OWNER))
 986                 return -EOPNOTSUPP;
 987
 988         trans = nft_trans_alloc(ctx, NFT_MSG_NEWTABLE,
 989                                 sizeof(struct nft_trans_table));
 990         if (trans == NULL)
 991                 return -ENOMEM;
 992
 993         if ((flags & NFT_TABLE_F_DORMANT) &&
 994             !(ctx->table->flags & NFT_TABLE_F_DORMANT)) {
 995                 ctx->table->flags |= NFT_TABLE_F_DORMANT;
 996                 if (!(ctx->table->flags & __NFT_TABLE_F_UPDATE))
 997                         ctx->table->flags |= __NFT_TABLE_F_WAS_AWAKEN;
 998         } else if (!(flags & NFT_TABLE_F_DORMANT) &&
 999                    ctx->table->flags & NFT_TABLE_F_DORMANT) {
1000                 ctx->table->flags &= ~NFT_TABLE_F_DORMANT;
1001                 if (!(ctx->table->flags & __NFT_TABLE_F_UPDATE)) {
1002                         ret = nf_tables_table_enable(ctx->net, ctx->table);
1003                         if (ret < 0)
1004                                 goto err_register_hooks;
1005
1006                         ctx->table->flags |= __NFT_TABLE_F_WAS_DORMANT;
1007                 }
1008         }
1009
1010         nft_trans_table_update(trans) = true;
1011         nft_trans_commit_list_add_tail(ctx->net, trans);
1012
1013         return 0;
1014
1015 err_register_hooks:
1016         nft_trans_destroy(trans);
1017         return ret;
1018 }
1019
1020 static u32 nft_chain_hash(const void *data, u32 len, u32 seed)
1021 {
1022         const char *name = data;
1023
1024         return jhash(name, strlen(name), seed);
1025 }
1026
1027 static u32 nft_chain_hash_obj(const void *data, u32 len, u32 seed)
1028 {
1029         const struct nft_chain *chain = data;
1030
1031         return nft_chain_hash(chain->name, 0, seed);
1032 }
1033
1034 static int nft_chain_hash_cmp(struct rhashtable_compare_arg *arg,
1035                               const void *ptr)
1036 {
1037         const struct nft_chain *chain = ptr;
1038         const char *name = arg->key;
1039
1040         return strcmp(chain->name, name);
1041 }
1042
1043 static u32 nft_objname_hash(const void *data, u32 len, u32 seed)
1044 {
1045         const struct nft_object_hash_key *k = data;
1046
1047         seed ^= hash_ptr(k->table, 32);
1048
1049         return jhash(k->name, strlen(k->name), seed);
1050 }
1051
1052 static u32 nft_objname_hash_obj(const void *data, u32 len, u32 seed)
1053 {
1054         const struct nft_object *obj = data;
1055
1056         return nft_objname_hash(&obj->key, 0, seed);
1057 }
1058
1059 static int nft_objname_hash_cmp(struct rhashtable_compare_arg *arg,
1060                                 const void *ptr)
1061 {
1062         const struct nft_object_hash_key *k = arg->key;
1063         const struct nft_object *obj = ptr;
1064
1065         if (obj->key.table != k->table)
1066                 return -1;
1067
1068         return strcmp(obj->key.name, k->name);
1069 }
1070
1071 static int nf_tables_newtable(struct sk_buff *skb, const struct nfnl_info *info,
1072                               const struct nlattr * const nla[])
1073 {
1074         struct nftables_pernet *nft_net = nft_pernet(info->net);
1075         struct netlink_ext_ack *extack = info->extack;
1076         u8 genmask = nft_genmask_next(info->net);
1077         u8 family = info->nfmsg->nfgen_family;
1078         struct net *net = info->net;
1079         const struct nlattr *attr;
1080         struct nft_table *table;
1081         struct nft_ctx ctx;
1082         u32 flags = 0;
1083         int err;
1084
1085         lockdep_assert_held(&nft_net->commit_mutex);
1086         attr = nla[NFTA_TABLE_NAME];
1087         table = nft_table_lookup(net, attr, family, genmask,
1088                                  NETLINK_CB(skb).portid);
1089         if (IS_ERR(table)) {
1090                 if (PTR_ERR(table) != -ENOENT)
1091                         return PTR_ERR(table);
1092         } else {
1093                 if (info->nlh->nlmsg_flags & NLM_F_EXCL) {
1094                         NL_SET_BAD_ATTR(extack, attr);
1095                         return -EEXIST;
1096                 }
1097                 if (info->nlh->nlmsg_flags & NLM_F_REPLACE)
1098                         return -EOPNOTSUPP;
1099
1100                 nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
1101
1102                 return nf_tables_updtable(&ctx);
1103         }
1104
1105         if (nla[NFTA_TABLE_FLAGS]) {
1106                 flags = ntohl(nla_get_be32(nla[NFTA_TABLE_FLAGS]));
1107                 if (flags & ~NFT_TABLE_F_MASK)
1108                         return -EOPNOTSUPP;
1109         }
1110
1111         err = -ENOMEM;
1112         table = kzalloc(sizeof(*table), GFP_KERNEL);
1113         if (table == NULL)
1114                 goto err_kzalloc;
1115
1116         table->name = nla_strdup(attr, GFP_KERNEL);
1117         if (table->name == NULL)
1118                 goto err_strdup;
1119
1120         if (nla[NFTA_TABLE_USERDATA]) {
1121                 table->udata = nla_memdup(nla[NFTA_TABLE_USERDATA], GFP_KERNEL);
1122                 if (table->udata == NULL)
1123                         goto err_table_udata;
1124
1125                 table->udlen = nla_len(nla[NFTA_TABLE_USERDATA]);
1126         }
1127
1128         err = rhltable_init(&table->chains_ht, &nft_chain_ht_params);
1129         if (err)
1130                 goto err_chain_ht;
1131
1132         INIT_LIST_HEAD(&table->chains);
1133         INIT_LIST_HEAD(&table->sets);
1134         INIT_LIST_HEAD(&table->objects);
1135         INIT_LIST_HEAD(&table->flowtables);
1136         table->family = family;
1137         table->flags = flags;
1138         table->handle = ++table_handle;
1139         if (table->flags & NFT_TABLE_F_OWNER)
1140                 table->nlpid = NETLINK_CB(skb).portid;
1141
1142         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
1143         err = nft_trans_table_add(&ctx, NFT_MSG_NEWTABLE);
1144         if (err < 0)
1145                 goto err_trans;
1146
1147         list_add_tail_rcu(&table->list, &nft_net->tables);
1148         return 0;
1149 err_trans:
1150         rhltable_destroy(&table->chains_ht);
1151 err_chain_ht:
1152         kfree(table->udata);
1153 err_table_udata:
1154         kfree(table->name);
1155 err_strdup:
1156         kfree(table);
1157 err_kzalloc:
1158         return err;
1159 }
1160
1161 static int nft_flush_table(struct nft_ctx *ctx)
1162 {
1163         struct nft_flowtable *flowtable, *nft;
1164         struct nft_chain *chain, *nc;
1165         struct nft_object *obj, *ne;
1166         struct nft_set *set, *ns;
1167         int err;
1168
1169         list_for_each_entry(chain, &ctx->table->chains, list) {
1170                 if (!nft_is_active_next(ctx->net, chain))
1171                         continue;
1172
1173                 if (nft_chain_is_bound(chain))
1174                         continue;
1175
1176                 ctx->chain = chain;
1177
1178                 err = nft_delrule_by_chain(ctx);
1179                 if (err < 0)
1180                         goto out;
1181         }
1182
1183         list_for_each_entry_safe(set, ns, &ctx->table->sets, list) {
1184                 if (!nft_is_active_next(ctx->net, set))
1185                         continue;
1186
1187                 if (nft_set_is_anonymous(set) &&
1188                     !list_empty(&set->bindings))
1189                         continue;
1190
1191                 err = nft_delset(ctx, set);
1192                 if (err < 0)
1193                         goto out;
1194         }
1195
1196         list_for_each_entry_safe(flowtable, nft, &ctx->table->flowtables, list) {
1197                 if (!nft_is_active_next(ctx->net, flowtable))
1198                         continue;
1199
1200                 err = nft_delflowtable(ctx, flowtable);
1201                 if (err < 0)
1202                         goto out;
1203         }
1204
1205         list_for_each_entry_safe(obj, ne, &ctx->table->objects, list) {
1206                 if (!nft_is_active_next(ctx->net, obj))
1207                         continue;
1208
1209                 err = nft_delobj(ctx, obj);
1210                 if (err < 0)
1211                         goto out;
1212         }
1213
1214         list_for_each_entry_safe(chain, nc, &ctx->table->chains, list) {
1215                 if (!nft_is_active_next(ctx->net, chain))
1216                         continue;
1217
1218                 if (nft_chain_is_bound(chain))
1219                         continue;
1220
1221                 ctx->chain = chain;
1222
1223                 err = nft_delchain(ctx);
1224                 if (err < 0)
1225                         goto out;
1226         }
1227
1228         err = nft_deltable(ctx);
1229 out:
1230         return err;
1231 }
1232
1233 static int nft_flush(struct nft_ctx *ctx, int family)
1234 {
1235         struct nftables_pernet *nft_net = nft_pernet(ctx->net);
1236         const struct nlattr * const *nla = ctx->nla;
1237         struct nft_table *table, *nt;
1238         int err = 0;
1239
1240         list_for_each_entry_safe(table, nt, &nft_net->tables, list) {
1241                 if (family != AF_UNSPEC && table->family != family)
1242                         continue;
1243
1244                 ctx->family = table->family;
1245
1246                 if (!nft_is_active_next(ctx->net, table))
1247                         continue;
1248
1249                 if (nft_table_has_owner(table) && table->nlpid != ctx->portid)
1250                         continue;
1251
1252                 if (nla[NFTA_TABLE_NAME] &&
1253                     nla_strcmp(nla[NFTA_TABLE_NAME], table->name) != 0)
1254                         continue;
1255
1256                 ctx->table = table;
1257
1258                 err = nft_flush_table(ctx);
1259                 if (err < 0)
1260                         goto out;
1261         }
1262 out:
1263         return err;
1264 }
1265
1266 static int nf_tables_deltable(struct sk_buff *skb, const struct nfnl_info *info,
1267                               const struct nlattr * const nla[])
1268 {
1269         struct netlink_ext_ack *extack = info->extack;
1270         u8 genmask = nft_genmask_next(info->net);
1271         u8 family = info->nfmsg->nfgen_family;
1272         struct net *net = info->net;
1273         const struct nlattr *attr;
1274         struct nft_table *table;
1275         struct nft_ctx ctx;
1276
1277         nft_ctx_init(&ctx, net, skb, info->nlh, 0, NULL, NULL, nla);
1278         if (family == AF_UNSPEC ||
1279             (!nla[NFTA_TABLE_NAME] && !nla[NFTA_TABLE_HANDLE]))
1280                 return nft_flush(&ctx, family);
1281
1282         if (nla[NFTA_TABLE_HANDLE]) {
1283                 attr = nla[NFTA_TABLE_HANDLE];
1284                 table = nft_table_lookup_byhandle(net, attr, genmask,
1285                                                   NETLINK_CB(skb).portid);
1286         } else {
1287                 attr = nla[NFTA_TABLE_NAME];
1288                 table = nft_table_lookup(net, attr, family, genmask,
1289                                          NETLINK_CB(skb).portid);
1290         }
1291
1292         if (IS_ERR(table)) {
1293                 NL_SET_BAD_ATTR(extack, attr);
1294                 return PTR_ERR(table);
1295         }
1296
1297         if (info->nlh->nlmsg_flags & NLM_F_NONREC &&
1298             table->use > 0)
1299                 return -EBUSY;
1300
1301         ctx.family = family;
1302         ctx.table = table;
1303
1304         return nft_flush_table(&ctx);
1305 }
1306
1307 static void nf_tables_table_destroy(struct nft_ctx *ctx)
1308 {
1309         if (WARN_ON(ctx->table->use > 0))
1310                 return;
1311
1312         rhltable_destroy(&ctx->table->chains_ht);
1313         kfree(ctx->table->name);
1314         kfree(ctx->table->udata);
1315         kfree(ctx->table);
1316 }
1317
1318 void nft_register_chain_type(const struct nft_chain_type *ctype)
1319 {
1320         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1321         if (WARN_ON(__nft_chain_type_get(ctype->family, ctype->type))) {
1322                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1323                 return;
1324         }
1325         chain_type[ctype->family][ctype->type] = ctype;
1326         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1327 }
1328 EXPORT_SYMBOL_GPL(nft_register_chain_type);
1329
1330 void nft_unregister_chain_type(const struct nft_chain_type *ctype)
1331 {
1332         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1333         chain_type[ctype->family][ctype->type] = NULL;
1334         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1335 }
1336 EXPORT_SYMBOL_GPL(nft_unregister_chain_type);
1337
1338 /*
1339  * Chains
1340  */
1341
1342 static struct nft_chain *
1343 nft_chain_lookup_byhandle(const struct nft_table *table, u64 handle, u8 genmask)
1344 {
1345         struct nft_chain *chain;
1346
1347         list_for_each_entry(chain, &table->chains, list) {
1348                 if (chain->handle == handle &&
1349                     nft_active_genmask(chain, genmask))
1350                         return chain;
1351         }
1352
1353         return ERR_PTR(-ENOENT);
1354 }
1355
1356 static bool lockdep_commit_lock_is_held(const struct net *net)
1357 {
1358 #ifdef CONFIG_PROVE_LOCKING
1359         struct nftables_pernet *nft_net = nft_pernet(net);
1360
1361         return lockdep_is_held(&nft_net->commit_mutex);
1362 #else
1363         return true;
1364 #endif
1365 }
1366
1367 static struct nft_chain *nft_chain_lookup(struct net *net,
1368                                           struct nft_table *table,
1369                                           const struct nlattr *nla, u8 genmask)
1370 {
1371         char search[NFT_CHAIN_MAXNAMELEN + 1];
1372         struct rhlist_head *tmp, *list;
1373         struct nft_chain *chain;
1374
1375         if (nla == NULL)
1376                 return ERR_PTR(-EINVAL);
1377
1378         nla_strscpy(search, nla, sizeof(search));
1379
1380         WARN_ON(!rcu_read_lock_held() &&
1381                 !lockdep_commit_lock_is_held(net));
1382
1383         chain = ERR_PTR(-ENOENT);
1384         rcu_read_lock();
1385         list = rhltable_lookup(&table->chains_ht, search, nft_chain_ht_params);
1386         if (!list)
1387                 goto out_unlock;
1388
1389         rhl_for_each_entry_rcu(chain, tmp, list, rhlhead) {
1390                 if (nft_active_genmask(chain, genmask))
1391                         goto out_unlock;
1392         }
1393         chain = ERR_PTR(-ENOENT);
1394 out_unlock:
1395         rcu_read_unlock();
1396         return chain;
1397 }
1398
1399 static const struct nla_policy nft_chain_policy[NFTA_CHAIN_MAX + 1] = {
1400         [NFTA_CHAIN_TABLE]      = { .type = NLA_STRING,
1401                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
1402         [NFTA_CHAIN_HANDLE]     = { .type = NLA_U64 },
1403         [NFTA_CHAIN_NAME]       = { .type = NLA_STRING,
1404                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
1405         [NFTA_CHAIN_HOOK]       = { .type = NLA_NESTED },
1406         [NFTA_CHAIN_POLICY]     = { .type = NLA_U32 },
1407         [NFTA_CHAIN_TYPE]       = { .type = NLA_STRING,
1408                                     .len = NFT_MODULE_AUTOLOAD_LIMIT },
1409         [NFTA_CHAIN_COUNTERS]   = { .type = NLA_NESTED },
1410         [NFTA_CHAIN_FLAGS]      = { .type = NLA_U32 },
1411         [NFTA_CHAIN_ID]         = { .type = NLA_U32 },
1412         [NFTA_CHAIN_USERDATA]   = { .type = NLA_BINARY,
1413                                     .len = NFT_USERDATA_MAXLEN },
1414 };
1415
1416 static const struct nla_policy nft_hook_policy[NFTA_HOOK_MAX + 1] = {
1417         [NFTA_HOOK_HOOKNUM]     = { .type = NLA_U32 },
1418         [NFTA_HOOK_PRIORITY]    = { .type = NLA_U32 },
1419         [NFTA_HOOK_DEV]         = { .type = NLA_STRING,
1420                                     .len = IFNAMSIZ - 1 },
1421 };
1422
1423 static int nft_dump_stats(struct sk_buff *skb, struct nft_stats __percpu *stats)
1424 {
1425         struct nft_stats *cpu_stats, total;
1426         struct nlattr *nest;
1427         unsigned int seq;
1428         u64 pkts, bytes;
1429         int cpu;
1430
1431         if (!stats)
1432                 return 0;
1433
1434         memset(&total, 0, sizeof(total));
1435         for_each_possible_cpu(cpu) {
1436                 cpu_stats = per_cpu_ptr(stats, cpu);
1437                 do {
1438                         seq = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
1439                         pkts = cpu_stats->pkts;
1440                         bytes = cpu_stats->bytes;
1441                 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, seq));
1442                 total.pkts += pkts;
1443                 total.bytes += bytes;
1444         }
1445         nest = nla_nest_start_noflag(skb, NFTA_CHAIN_COUNTERS);
1446         if (nest == NULL)
1447                 goto nla_put_failure;
1448
1449         if (nla_put_be64(skb, NFTA_COUNTER_PACKETS, cpu_to_be64(total.pkts),
1450                          NFTA_COUNTER_PAD) ||
1451             nla_put_be64(skb, NFTA_COUNTER_BYTES, cpu_to_be64(total.bytes),
1452                          NFTA_COUNTER_PAD))
1453                 goto nla_put_failure;
1454
1455         nla_nest_end(skb, nest);
1456         return 0;
1457
1458 nla_put_failure:
1459         return -ENOSPC;
1460 }
1461
1462 static int nft_dump_basechain_hook(struct sk_buff *skb, int family,
1463                                    const struct nft_base_chain *basechain)
1464 {
1465         const struct nf_hook_ops *ops = &basechain->ops;
1466         struct nft_hook *hook, *first = NULL;
1467         struct nlattr *nest, *nest_devs;
1468         int n = 0;
1469
1470         nest = nla_nest_start_noflag(skb, NFTA_CHAIN_HOOK);
1471         if (nest == NULL)
1472                 goto nla_put_failure;
1473         if (nla_put_be32(skb, NFTA_HOOK_HOOKNUM, htonl(ops->hooknum)))
1474                 goto nla_put_failure;
1475         if (nla_put_be32(skb, NFTA_HOOK_PRIORITY, htonl(ops->priority)))
1476                 goto nla_put_failure;
1477
1478         if (nft_base_chain_netdev(family, ops->hooknum)) {
1479                 nest_devs = nla_nest_start_noflag(skb, NFTA_HOOK_DEVS);
1480                 list_for_each_entry(hook, &basechain->hook_list, list) {
1481                         if (!first)
1482                                 first = hook;
1483
1484                         if (nla_put_string(skb, NFTA_DEVICE_NAME,
1485                                            hook->ops.dev->name))
1486                                 goto nla_put_failure;
1487                         n++;
1488                 }
1489                 nla_nest_end(skb, nest_devs);
1490
1491                 if (n == 1 &&
1492                     nla_put_string(skb, NFTA_HOOK_DEV, first->ops.dev->name))
1493                         goto nla_put_failure;
1494         }
1495         nla_nest_end(skb, nest);
1496
1497         return 0;
1498 nla_put_failure:
1499         return -1;
1500 }
1501
1502 static int nf_tables_fill_chain_info(struct sk_buff *skb, struct net *net,
1503                                      u32 portid, u32 seq, int event, u32 flags,
1504                                      int family, const struct nft_table *table,
1505                                      const struct nft_chain *chain)
1506 {
1507         struct nlmsghdr *nlh;
1508
1509         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
1510         nlh = nfnl_msg_put(skb, portid, seq, event, flags, family,
1511                            NFNETLINK_V0, nft_base_seq(net));
1512         if (!nlh)
1513                 goto nla_put_failure;
1514
1515         if (nla_put_string(skb, NFTA_CHAIN_TABLE, table->name))
1516                 goto nla_put_failure;
1517         if (nla_put_be64(skb, NFTA_CHAIN_HANDLE, cpu_to_be64(chain->handle),
1518                          NFTA_CHAIN_PAD))
1519                 goto nla_put_failure;
1520         if (nla_put_string(skb, NFTA_CHAIN_NAME, chain->name))
1521                 goto nla_put_failure;
1522
1523         if (nft_is_base_chain(chain)) {
1524                 const struct nft_base_chain *basechain = nft_base_chain(chain);
1525                 struct nft_stats __percpu *stats;
1526
1527                 if (nft_dump_basechain_hook(skb, family, basechain))
1528                         goto nla_put_failure;
1529
1530                 if (nla_put_be32(skb, NFTA_CHAIN_POLICY,
1531                                  htonl(basechain->policy)))
1532                         goto nla_put_failure;
1533
1534                 if (nla_put_string(skb, NFTA_CHAIN_TYPE, basechain->type->name))
1535                         goto nla_put_failure;
1536
1537                 stats = rcu_dereference_check(basechain->stats,
1538                                               lockdep_commit_lock_is_held(net));
1539                 if (nft_dump_stats(skb, stats))
1540                         goto nla_put_failure;
1541         }
1542
1543         if (chain->flags &&
1544             nla_put_be32(skb, NFTA_CHAIN_FLAGS, htonl(chain->flags)))
1545                 goto nla_put_failure;
1546
1547         if (nla_put_be32(skb, NFTA_CHAIN_USE, htonl(chain->use)))
1548                 goto nla_put_failure;
1549
1550         if (chain->udata &&
1551             nla_put(skb, NFTA_CHAIN_USERDATA, chain->udlen, chain->udata))
1552                 goto nla_put_failure;
1553
1554         nlmsg_end(skb, nlh);
1555         return 0;
1556
1557 nla_put_failure:
1558         nlmsg_trim(skb, nlh);
1559         return -1;
1560 }
1561
1562 static void nf_tables_chain_notify(const struct nft_ctx *ctx, int event)
1563 {
1564         struct nftables_pernet *nft_net;
1565         struct sk_buff *skb;
1566         int err;
1567
1568         if (!ctx->report &&
1569             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
1570                 return;
1571
1572         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1573         if (skb == NULL)
1574                 goto err;
1575
1576         err = nf_tables_fill_chain_info(skb, ctx->net, ctx->portid, ctx->seq,
1577                                         event, 0, ctx->family, ctx->table,
1578                                         ctx->chain);
1579         if (err < 0) {
1580                 kfree_skb(skb);
1581                 goto err;
1582         }
1583
1584         nft_net = nft_pernet(ctx->net);
1585         nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);
1586         return;
1587 err:
1588         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
1589 }
1590
1591 static int nf_tables_dump_chains(struct sk_buff *skb,
1592                                  struct netlink_callback *cb)
1593 {
1594         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
1595         unsigned int idx = 0, s_idx = cb->args[0];
1596         struct net *net = sock_net(skb->sk);
1597         int family = nfmsg->nfgen_family;
1598         struct nftables_pernet *nft_net;
1599         const struct nft_table *table;
1600         const struct nft_chain *chain;
1601
1602         rcu_read_lock();
1603         nft_net = nft_pernet(net);
1604         cb->seq = nft_net->base_seq;
1605
1606         list_for_each_entry_rcu(table, &nft_net->tables, list) {
1607                 if (family != NFPROTO_UNSPEC && family != table->family)
1608                         continue;
1609
1610                 list_for_each_entry_rcu(chain, &table->chains, list) {
1611                         if (idx < s_idx)
1612                                 goto cont;
1613                         if (idx > s_idx)
1614                                 memset(&cb->args[1], 0,
1615                                        sizeof(cb->args) - sizeof(cb->args[0]));
1616                         if (!nft_is_active(net, chain))
1617                                 continue;
1618                         if (nf_tables_fill_chain_info(skb, net,
1619                                                       NETLINK_CB(cb->skb).portid,
1620                                                       cb->nlh->nlmsg_seq,
1621                                                       NFT_MSG_NEWCHAIN,
1622                                                       NLM_F_MULTI,
1623                                                       table->family, table,
1624                                                       chain) < 0)
1625                                 goto done;
1626
1627                         nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1628 cont:
1629                         idx++;
1630                 }
1631         }
1632 done:
1633         rcu_read_unlock();
1634         cb->args[0] = idx;
1635         return skb->len;
1636 }
1637
1638 /* called with rcu_read_lock held */
1639 static int nf_tables_getchain(struct sk_buff *skb, const struct nfnl_info *info,
1640                               const struct nlattr * const nla[])
1641 {
1642         struct netlink_ext_ack *extack = info->extack;
1643         u8 genmask = nft_genmask_cur(info->net);
1644         u8 family = info->nfmsg->nfgen_family;
1645         const struct nft_chain *chain;
1646         struct net *net = info->net;
1647         struct nft_table *table;
1648         struct sk_buff *skb2;
1649         int err;
1650
1651         if (info->nlh->nlmsg_flags & NLM_F_DUMP) {
1652                 struct netlink_dump_control c = {
1653                         .dump = nf_tables_dump_chains,
1654                         .module = THIS_MODULE,
1655                 };
1656
1657                 return nft_netlink_dump_start_rcu(info->sk, skb, info->nlh, &c);
1658         }
1659
1660         table = nft_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, genmask, 0);
1661         if (IS_ERR(table)) {
1662                 NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TABLE]);
1663                 return PTR_ERR(table);
1664         }
1665
1666         chain = nft_chain_lookup(net, table, nla[NFTA_CHAIN_NAME], genmask);
1667         if (IS_ERR(chain)) {
1668                 NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_NAME]);
1669                 return PTR_ERR(chain);
1670         }
1671
1672         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
1673         if (!skb2)
1674                 return -ENOMEM;
1675
1676         err = nf_tables_fill_chain_info(skb2, net, NETLINK_CB(skb).portid,
1677                                         info->nlh->nlmsg_seq, NFT_MSG_NEWCHAIN,
1678                                         0, family, table, chain);
1679         if (err < 0)
1680                 goto err_fill_chain_info;
1681
1682         return nfnetlink_unicast(skb2, net, NETLINK_CB(skb).portid);
1683
1684 err_fill_chain_info:
1685         kfree_skb(skb2);
1686         return err;
1687 }
1688
1689 static const struct nla_policy nft_counter_policy[NFTA_COUNTER_MAX + 1] = {
1690         [NFTA_COUNTER_PACKETS]  = { .type = NLA_U64 },
1691         [NFTA_COUNTER_BYTES]    = { .type = NLA_U64 },
1692 };
1693
1694 static struct nft_stats __percpu *nft_stats_alloc(const struct nlattr *attr)
1695 {
1696         struct nlattr *tb[NFTA_COUNTER_MAX+1];
1697         struct nft_stats __percpu *newstats;
1698         struct nft_stats *stats;
1699         int err;
1700
1701         err = nla_parse_nested_deprecated(tb, NFTA_COUNTER_MAX, attr,
1702                                           nft_counter_policy, NULL);
1703         if (err < 0)
1704                 return ERR_PTR(err);
1705
1706         if (!tb[NFTA_COUNTER_BYTES] || !tb[NFTA_COUNTER_PACKETS])
1707                 return ERR_PTR(-EINVAL);
1708
1709         newstats = netdev_alloc_pcpu_stats(struct nft_stats);
1710         if (newstats == NULL)
1711                 return ERR_PTR(-ENOMEM);
1712
1713         /* Restore old counters on this cpu, no problem. Per-cpu statistics
1714          * are not exposed to userspace.
1715          */
1716         preempt_disable();
1717         stats = this_cpu_ptr(newstats);
1718         stats->bytes = be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_BYTES]));
1719         stats->pkts = be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_PACKETS]));
1720         preempt_enable();
1721
1722         return newstats;
1723 }
1724
1725 static void nft_chain_stats_replace(struct nft_trans *trans)
1726 {
1727         struct nft_base_chain *chain = nft_base_chain(trans->ctx.chain);
1728
1729         if (!nft_trans_chain_stats(trans))
1730                 return;
1731
1732         nft_trans_chain_stats(trans) =
1733                 rcu_replace_pointer(chain->stats, nft_trans_chain_stats(trans),
1734                                     lockdep_commit_lock_is_held(trans->ctx.net));
1735
1736         if (!nft_trans_chain_stats(trans))
1737                 static_branch_inc(&nft_counters_enabled);
1738 }
1739
1740 static void nf_tables_chain_free_chain_rules(struct nft_chain *chain)
1741 {
1742         struct nft_rule **g0 = rcu_dereference_raw(chain->rules_gen_0);
1743         struct nft_rule **g1 = rcu_dereference_raw(chain->rules_gen_1);
1744
1745         if (g0 != g1)
1746                 kvfree(g1);
1747         kvfree(g0);
1748
1749         /* should be NULL either via abort or via successful commit */
1750         WARN_ON_ONCE(chain->rules_next);
1751         kvfree(chain->rules_next);
1752 }
1753
1754 void nf_tables_chain_destroy(struct nft_ctx *ctx)
1755 {
1756         struct nft_chain *chain = ctx->chain;
1757         struct nft_hook *hook, *next;
1758
1759         if (WARN_ON(chain->use > 0))
1760                 return;
1761
1762         /* no concurrent access possible anymore */
1763         nf_tables_chain_free_chain_rules(chain);
1764
1765         if (nft_is_base_chain(chain)) {
1766                 struct nft_base_chain *basechain = nft_base_chain(chain);
1767
1768                 if (nft_base_chain_netdev(ctx->family, basechain->ops.hooknum)) {
1769                         list_for_each_entry_safe(hook, next,
1770                                                  &basechain->hook_list, list) {
1771                                 list_del_rcu(&hook->list);
1772                                 kfree_rcu(hook, rcu);
1773                         }
1774                 }
1775                 module_put(basechain->type->owner);
1776                 if (rcu_access_pointer(basechain->stats)) {
1777                         static_branch_dec(&nft_counters_enabled);
1778                         free_percpu(rcu_dereference_raw(basechain->stats));
1779                 }
1780                 kfree(chain->name);
1781                 kfree(chain->udata);
1782                 kfree(basechain);
1783         } else {
1784                 kfree(chain->name);
1785                 kfree(chain->udata);
1786                 kfree(chain);
1787         }
1788 }
1789
1790 static struct nft_hook *nft_netdev_hook_alloc(struct net *net,
1791                                               const struct nlattr *attr)
1792 {
1793         struct net_device *dev;
1794         char ifname[IFNAMSIZ];
1795         struct nft_hook *hook;
1796         int err;
1797
1798         hook = kmalloc(sizeof(struct nft_hook), GFP_KERNEL);
1799         if (!hook) {
1800                 err = -ENOMEM;
1801                 goto err_hook_alloc;
1802         }
1803
1804         nla_strscpy(ifname, attr, IFNAMSIZ);
1805         /* nf_tables_netdev_event() is called under rtnl_mutex, this is
1806          * indirectly serializing all the other holders of the commit_mutex with
1807          * the rtnl_mutex.
1808          */
1809         dev = __dev_get_by_name(net, ifname);
1810         if (!dev) {
1811                 err = -ENOENT;
1812                 goto err_hook_dev;
1813         }
1814         hook->ops.dev = dev;
1815         hook->inactive = false;
1816
1817         return hook;
1818
1819 err_hook_dev:
1820         kfree(hook);
1821 err_hook_alloc:
1822         return ERR_PTR(err);
1823 }
1824
1825 static struct nft_hook *nft_hook_list_find(struct list_head *hook_list,
1826                                            const struct nft_hook *this)
1827 {
1828         struct nft_hook *hook;
1829
1830         list_for_each_entry(hook, hook_list, list) {
1831                 if (this->ops.dev == hook->ops.dev)
1832                         return hook;
1833         }
1834
1835         return NULL;
1836 }
1837
1838 static int nf_tables_parse_netdev_hooks(struct net *net,
1839                                         const struct nlattr *attr,
1840                                         struct list_head *hook_list)
1841 {
1842         struct nft_hook *hook, *next;
1843         const struct nlattr *tmp;
1844         int rem, n = 0, err;
1845
1846         nla_for_each_nested(tmp, attr, rem) {
1847                 if (nla_type(tmp) != NFTA_DEVICE_NAME) {
1848                         err = -EINVAL;
1849                         goto err_hook;
1850                 }
1851
1852                 hook = nft_netdev_hook_alloc(net, tmp);
1853                 if (IS_ERR(hook)) {
1854                         err = PTR_ERR(hook);
1855                         goto err_hook;
1856                 }
1857                 if (nft_hook_list_find(hook_list, hook)) {
1858                         kfree(hook);
1859                         err = -EEXIST;
1860                         goto err_hook;
1861                 }
1862                 list_add_tail(&hook->list, hook_list);
1863                 n++;
1864
1865                 if (n == NFT_NETDEVICE_MAX) {
1866                         err = -EFBIG;
1867                         goto err_hook;
1868                 }
1869         }
1870
1871         return 0;
1872
1873 err_hook:
1874         list_for_each_entry_safe(hook, next, hook_list, list) {
1875                 list_del(&hook->list);
1876                 kfree(hook);
1877         }
1878         return err;
1879 }
1880
1881 struct nft_chain_hook {
1882         u32                             num;
1883         s32                             priority;
1884         const struct nft_chain_type     *type;
1885         struct list_head                list;
1886 };
1887
1888 static int nft_chain_parse_netdev(struct net *net,
1889                                   struct nlattr *tb[],
1890                                   struct list_head *hook_list)
1891 {
1892         struct nft_hook *hook;
1893         int err;
1894
1895         if (tb[NFTA_HOOK_DEV]) {
1896                 hook = nft_netdev_hook_alloc(net, tb[NFTA_HOOK_DEV]);
1897                 if (IS_ERR(hook))
1898                         return PTR_ERR(hook);
1899
1900                 list_add_tail(&hook->list, hook_list);
1901         } else if (tb[NFTA_HOOK_DEVS]) {
1902                 err = nf_tables_parse_netdev_hooks(net, tb[NFTA_HOOK_DEVS],
1903                                                    hook_list);
1904                 if (err < 0)
1905                         return err;
1906
1907                 if (list_empty(hook_list))
1908                         return -EINVAL;
1909         } else {
1910                 return -EINVAL;
1911         }
1912
1913         return 0;
1914 }
1915
1916 static int nft_chain_parse_hook(struct net *net,
1917                                 const struct nlattr * const nla[],
1918                                 struct nft_chain_hook *hook, u8 family,
1919                                 struct netlink_ext_ack *extack, bool autoload)
1920 {
1921         struct nftables_pernet *nft_net = nft_pernet(net);
1922         struct nlattr *ha[NFTA_HOOK_MAX + 1];
1923         const struct nft_chain_type *type;
1924         int err;
1925
1926         lockdep_assert_held(&nft_net->commit_mutex);
1927         lockdep_nfnl_nft_mutex_not_held();
1928
1929         err = nla_parse_nested_deprecated(ha, NFTA_HOOK_MAX,
1930                                           nla[NFTA_CHAIN_HOOK],
1931                                           nft_hook_policy, NULL);
1932         if (err < 0)
1933                 return err;
1934
1935         if (ha[NFTA_HOOK_HOOKNUM] == NULL ||
1936             ha[NFTA_HOOK_PRIORITY] == NULL)
1937                 return -EINVAL;
1938
1939         hook->num = ntohl(nla_get_be32(ha[NFTA_HOOK_HOOKNUM]));
1940         hook->priority = ntohl(nla_get_be32(ha[NFTA_HOOK_PRIORITY]));
1941
1942         type = __nft_chain_type_get(family, NFT_CHAIN_T_DEFAULT);
1943         if (!type)
1944                 return -EOPNOTSUPP;
1945
1946         if (nla[NFTA_CHAIN_TYPE]) {
1947                 type = nf_tables_chain_type_lookup(net, nla[NFTA_CHAIN_TYPE],
1948                                                    family, autoload);
1949                 if (IS_ERR(type)) {
1950                         NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TYPE]);
1951                         return PTR_ERR(type);
1952                 }
1953         }
1954         if (hook->num >= NFT_MAX_HOOKS || !(type->hook_mask & (1 << hook->num)))
1955                 return -EOPNOTSUPP;
1956
1957         if (type->type == NFT_CHAIN_T_NAT &&
1958             hook->priority <= NF_IP_PRI_CONNTRACK)
1959                 return -EOPNOTSUPP;
1960
1961         if (!try_module_get(type->owner)) {
1962                 if (nla[NFTA_CHAIN_TYPE])
1963                         NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TYPE]);
1964                 return -ENOENT;
1965         }
1966
1967         hook->type = type;
1968
1969         INIT_LIST_HEAD(&hook->list);
1970         if (nft_base_chain_netdev(family, hook->num)) {
1971                 err = nft_chain_parse_netdev(net, ha, &hook->list);
1972                 if (err < 0) {
1973                         module_put(type->owner);
1974                         return err;
1975                 }
1976         } else if (ha[NFTA_HOOK_DEV] || ha[NFTA_HOOK_DEVS]) {
1977                 module_put(type->owner);
1978                 return -EOPNOTSUPP;
1979         }
1980
1981         return 0;
1982 }
1983
1984 static void nft_chain_release_hook(struct nft_chain_hook *hook)
1985 {
1986         struct nft_hook *h, *next;
1987
1988         list_for_each_entry_safe(h, next, &hook->list, list) {
1989                 list_del(&h->list);
1990                 kfree(h);
1991         }
1992         module_put(hook->type->owner);
1993 }
1994
1995 struct nft_rules_old {
1996         struct rcu_head h;
1997         struct nft_rule **start;
1998 };
1999
2000 static struct nft_rule **nf_tables_chain_alloc_rules(const struct nft_chain *chain,
2001                                                      unsigned int alloc)
2002 {
2003         if (alloc > INT_MAX)
2004                 return NULL;
2005
2006         alloc += 1;     /* NULL, ends rules */
2007         if (sizeof(struct nft_rule *) > INT_MAX / alloc)
2008                 return NULL;
2009
2010         alloc *= sizeof(struct nft_rule *);
2011         alloc += sizeof(struct nft_rules_old);
2012
2013         return kvmalloc(alloc, GFP_KERNEL);
2014 }
2015
2016 static void nft_basechain_hook_init(struct nf_hook_ops *ops, u8 family,
2017                                     const struct nft_chain_hook *hook,
2018                                     struct nft_chain *chain)
2019 {
2020         ops->pf                 = family;
2021         ops->hooknum            = hook->num;
2022         ops->priority           = hook->priority;
2023         ops->priv               = chain;
2024         ops->hook               = hook->type->hooks[ops->hooknum];
2025         ops->hook_ops_type      = NF_HOOK_OP_NF_TABLES;
2026 }
2027
2028 static int nft_basechain_init(struct nft_base_chain *basechain, u8 family,
2029                               struct nft_chain_hook *hook, u32 flags)
2030 {
2031         struct nft_chain *chain;
2032         struct nft_hook *h;
2033
2034         basechain->type = hook->type;
2035         INIT_LIST_HEAD(&basechain->hook_list);
2036         chain = &basechain->chain;
2037
2038         if (nft_base_chain_netdev(family, hook->num)) {
2039                 list_splice_init(&hook->list, &basechain->hook_list);
2040                 list_for_each_entry(h, &basechain->hook_list, list)
2041                         nft_basechain_hook_init(&h->ops, family, hook, chain);
2042
2043                 basechain->ops.hooknum  = hook->num;
2044                 basechain->ops.priority = hook->priority;
2045         } else {
2046                 nft_basechain_hook_init(&basechain->ops, family, hook, chain);
2047         }
2048
2049         chain->flags |= NFT_CHAIN_BASE | flags;
2050         basechain->policy = NF_ACCEPT;
2051         if (chain->flags & NFT_CHAIN_HW_OFFLOAD &&
2052             nft_chain_offload_priority(basechain) < 0)
2053                 return -EOPNOTSUPP;
2054
2055         flow_block_init(&basechain->flow_block);
2056
2057         return 0;
2058 }
2059
2060 static int nft_chain_add(struct nft_table *table, struct nft_chain *chain)
2061 {
2062         int err;
2063
2064         err = rhltable_insert_key(&table->chains_ht, chain->name,
2065                                   &chain->rhlhead, nft_chain_ht_params);
2066         if (err)
2067                 return err;
2068
2069         list_add_tail_rcu(&chain->list, &table->chains);
2070
2071         return 0;
2072 }
2073
2074 static u64 chain_id;
2075
2076 static int nf_tables_addchain(struct nft_ctx *ctx, u8 family, u8 genmask,
2077                               u8 policy, u32 flags,
2078                               struct netlink_ext_ack *extack)
2079 {
2080         const struct nlattr * const *nla = ctx->nla;
2081         struct nft_table *table = ctx->table;
2082         struct nft_base_chain *basechain;
2083         struct nft_stats __percpu *stats;
2084         struct net *net = ctx->net;
2085         char name[NFT_NAME_MAXLEN];
2086         struct nft_trans *trans;
2087         struct nft_chain *chain;
2088         struct nft_rule **rules;
2089         int err;
2090
2091         if (table->use == UINT_MAX)
2092                 return -EOVERFLOW;
2093
2094         if (nla[NFTA_CHAIN_HOOK]) {
2095                 struct nft_chain_hook hook;
2096
2097                 if (flags & NFT_CHAIN_BINDING)
2098                         return -EOPNOTSUPP;
2099
2100                 err = nft_chain_parse_hook(net, nla, &hook, family, extack,
2101                                            true);
2102                 if (err < 0)
2103                         return err;
2104
2105                 basechain = kzalloc(sizeof(*basechain), GFP_KERNEL);
2106                 if (basechain == NULL) {
2107                         nft_chain_release_hook(&hook);
2108                         return -ENOMEM;
2109                 }
2110                 chain = &basechain->chain;
2111
2112                 if (nla[NFTA_CHAIN_COUNTERS]) {
2113                         stats = nft_stats_alloc(nla[NFTA_CHAIN_COUNTERS]);
2114                         if (IS_ERR(stats)) {
2115                                 nft_chain_release_hook(&hook);
2116                                 kfree(basechain);
2117                                 return PTR_ERR(stats);
2118                         }
2119                         rcu_assign_pointer(basechain->stats, stats);
2120                         static_branch_inc(&nft_counters_enabled);
2121                 }
2122
2123                 err = nft_basechain_init(basechain, family, &hook, flags);
2124                 if (err < 0) {
2125                         nft_chain_release_hook(&hook);
2126                         kfree(basechain);
2127                         return err;
2128                 }
2129         } else {
2130                 if (flags & NFT_CHAIN_BASE)
2131                         return -EINVAL;
2132                 if (flags & NFT_CHAIN_HW_OFFLOAD)
2133                         return -EOPNOTSUPP;
2134
2135                 chain = kzalloc(sizeof(*chain), GFP_KERNEL);
2136                 if (chain == NULL)
2137                         return -ENOMEM;
2138
2139                 chain->flags = flags;
2140         }
2141         ctx->chain = chain;
2142
2143         INIT_LIST_HEAD(&chain->rules);
2144         chain->handle = nf_tables_alloc_handle(table);
2145         chain->table = table;
2146
2147         if (nla[NFTA_CHAIN_NAME]) {
2148                 chain->name = nla_strdup(nla[NFTA_CHAIN_NAME], GFP_KERNEL);
2149         } else {
2150                 if (!(flags & NFT_CHAIN_BINDING)) {
2151                         err = -EINVAL;
2152                         goto err_destroy_chain;
2153                 }
2154
2155                 snprintf(name, sizeof(name), "__chain%llu", ++chain_id);
2156                 chain->name = kstrdup(name, GFP_KERNEL);
2157         }
2158
2159         if (!chain->name) {
2160                 err = -ENOMEM;
2161                 goto err_destroy_chain;
2162         }
2163
2164         if (nla[NFTA_CHAIN_USERDATA]) {
2165                 chain->udata = nla_memdup(nla[NFTA_CHAIN_USERDATA], GFP_KERNEL);
2166                 if (chain->udata == NULL) {
2167                         err = -ENOMEM;
2168                         goto err_destroy_chain;
2169                 }
2170                 chain->udlen = nla_len(nla[NFTA_CHAIN_USERDATA]);
2171         }
2172
2173         rules = nf_tables_chain_alloc_rules(chain, 0);
2174         if (!rules) {
2175                 err = -ENOMEM;
2176                 goto err_destroy_chain;
2177         }
2178
2179         *rules = NULL;
2180         rcu_assign_pointer(chain->rules_gen_0, rules);
2181         rcu_assign_pointer(chain->rules_gen_1, rules);
2182
2183         err = nf_tables_register_hook(net, table, chain);
2184         if (err < 0)
2185                 goto err_destroy_chain;
2186
2187         trans = nft_trans_chain_add(ctx, NFT_MSG_NEWCHAIN);
2188         if (IS_ERR(trans)) {
2189                 err = PTR_ERR(trans);
2190                 goto err_unregister_hook;
2191         }
2192
2193         nft_trans_chain_policy(trans) = NFT_CHAIN_POLICY_UNSET;
2194         if (nft_is_base_chain(chain))
2195                 nft_trans_chain_policy(trans) = policy;
2196
2197         err = nft_chain_add(table, chain);
2198         if (err < 0) {
2199                 nft_trans_destroy(trans);
2200                 goto err_unregister_hook;
2201         }
2202
2203         table->use++;
2204
2205         return 0;
2206 err_unregister_hook:
2207         nf_tables_unregister_hook(net, table, chain);
2208 err_destroy_chain:
2209         nf_tables_chain_destroy(ctx);
2210
2211         return err;
2212 }
2213
2214 static bool nft_hook_list_equal(struct list_head *hook_list1,
2215                                 struct list_head *hook_list2)
2216 {
2217         struct nft_hook *hook;
2218         int n = 0, m = 0;
2219
2220         n = 0;
2221         list_for_each_entry(hook, hook_list2, list) {
2222                 if (!nft_hook_list_find(hook_list1, hook))
2223                         return false;
2224
2225                 n++;
2226         }
2227         list_for_each_entry(hook, hook_list1, list)
2228                 m++;
2229
2230         return n == m;
2231 }
2232
2233 static int nf_tables_updchain(struct nft_ctx *ctx, u8 genmask, u8 policy,
2234                               u32 flags, const struct nlattr *attr,
2235                               struct netlink_ext_ack *extack)
2236 {
2237         const struct nlattr * const *nla = ctx->nla;
2238         struct nft_table *table = ctx->table;
2239         struct nft_chain *chain = ctx->chain;
2240         struct nft_base_chain *basechain;
2241         struct nft_stats *stats = NULL;
2242         struct nft_chain_hook hook;
2243         struct nf_hook_ops *ops;
2244         struct nft_trans *trans;
2245         int err;
2246
2247         if (chain->flags ^ flags)
2248                 return -EOPNOTSUPP;
2249
2250         if (nla[NFTA_CHAIN_HOOK]) {
2251                 if (!nft_is_base_chain(chain)) {
2252                         NL_SET_BAD_ATTR(extack, attr);
2253                         return -EEXIST;
2254                 }
2255                 err = nft_chain_parse_hook(ctx->net, nla, &hook, ctx->family,
2256                                            extack, false);
2257                 if (err < 0)
2258                         return err;
2259
2260                 basechain = nft_base_chain(chain);
2261                 if (basechain->type != hook.type) {
2262                         nft_chain_release_hook(&hook);
2263                         NL_SET_BAD_ATTR(extack, attr);
2264                         return -EEXIST;
2265                 }
2266
2267                 if (nft_base_chain_netdev(ctx->family, hook.num)) {
2268                         if (!nft_hook_list_equal(&basechain->hook_list,
2269                                                  &hook.list)) {
2270                                 nft_chain_release_hook(&hook);
2271                                 NL_SET_BAD_ATTR(extack, attr);
2272                                 return -EEXIST;
2273                         }
2274                 } else {
2275                         ops = &basechain->ops;
2276                         if (ops->hooknum != hook.num ||
2277                             ops->priority != hook.priority) {
2278                                 nft_chain_release_hook(&hook);
2279                                 NL_SET_BAD_ATTR(extack, attr);
2280                                 return -EEXIST;
2281                         }
2282                 }
2283                 nft_chain_release_hook(&hook);
2284         }
2285
2286         if (nla[NFTA_CHAIN_HANDLE] &&
2287             nla[NFTA_CHAIN_NAME]) {
2288                 struct nft_chain *chain2;
2289
2290                 chain2 = nft_chain_lookup(ctx->net, table,
2291                                           nla[NFTA_CHAIN_NAME], genmask);
2292                 if (!IS_ERR(chain2)) {
2293                         NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_NAME]);
2294                         return -EEXIST;
2295                 }
2296         }
2297
2298         if (nla[NFTA_CHAIN_COUNTERS]) {
2299                 if (!nft_is_base_chain(chain))
2300                         return -EOPNOTSUPP;
2301
2302                 stats = nft_stats_alloc(nla[NFTA_CHAIN_COUNTERS]);
2303                 if (IS_ERR(stats))
2304                         return PTR_ERR(stats);
2305         }
2306
2307         err = -ENOMEM;
2308         trans = nft_trans_alloc(ctx, NFT_MSG_NEWCHAIN,
2309                                 sizeof(struct nft_trans_chain));
2310         if (trans == NULL)
2311                 goto err;
2312
2313         nft_trans_chain_stats(trans) = stats;
2314         nft_trans_chain_update(trans) = true;
2315
2316         if (nla[NFTA_CHAIN_POLICY])
2317                 nft_trans_chain_policy(trans) = policy;
2318         else
2319                 nft_trans_chain_policy(trans) = -1;
2320
2321         if (nla[NFTA_CHAIN_HANDLE] &&
2322             nla[NFTA_CHAIN_NAME]) {
2323                 struct nftables_pernet *nft_net = nft_pernet(ctx->net);
2324                 struct nft_trans *tmp;
2325                 char *name;
2326
2327                 err = -ENOMEM;
2328                 name = nla_strdup(nla[NFTA_CHAIN_NAME], GFP_KERNEL);
2329                 if (!name)
2330                         goto err;
2331
2332                 err = -EEXIST;
2333                 list_for_each_entry(tmp, &nft_net->commit_list, list) {
2334                         if (tmp->msg_type == NFT_MSG_NEWCHAIN &&
2335                             tmp->ctx.table == table &&
2336                             nft_trans_chain_update(tmp) &&
2337                             nft_trans_chain_name(tmp) &&
2338                             strcmp(name, nft_trans_chain_name(tmp)) == 0) {
2339                                 NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_NAME]);
2340                                 kfree(name);
2341                                 goto err;
2342                         }
2343                 }
2344
2345                 nft_trans_chain_name(trans) = name;
2346         }
2347         nft_trans_commit_list_add_tail(ctx->net, trans);
2348
2349         return 0;
2350 err:
2351         free_percpu(stats);
2352         kfree(trans);
2353         return err;
2354 }
2355
2356 static struct nft_chain *nft_chain_lookup_byid(const struct net *net,
2357                                                const struct nlattr *nla)
2358 {
2359         struct nftables_pernet *nft_net = nft_pernet(net);
2360         u32 id = ntohl(nla_get_be32(nla));
2361         struct nft_trans *trans;
2362
2363         list_for_each_entry(trans, &nft_net->commit_list, list) {
2364                 struct nft_chain *chain = trans->ctx.chain;
2365
2366                 if (trans->msg_type == NFT_MSG_NEWCHAIN &&
2367                     id == nft_trans_chain_id(trans))
2368                         return chain;
2369         }
2370         return ERR_PTR(-ENOENT);
2371 }
2372
2373 static int nf_tables_newchain(struct sk_buff *skb, const struct nfnl_info *info,
2374                               const struct nlattr * const nla[])
2375 {
2376         struct nftables_pernet *nft_net = nft_pernet(info->net);
2377         struct netlink_ext_ack *extack = info->extack;
2378         u8 genmask = nft_genmask_next(info->net);
2379         u8 family = info->nfmsg->nfgen_family;
2380         struct nft_chain *chain = NULL;
2381         struct net *net = info->net;
2382         const struct nlattr *attr;
2383         struct nft_table *table;
2384         u8 policy = NF_ACCEPT;
2385         struct nft_ctx ctx;
2386         u64 handle = 0;
2387         u32 flags = 0;
2388
2389         lockdep_assert_held(&nft_net->commit_mutex);
2390
2391         table = nft_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, genmask,
2392                                  NETLINK_CB(skb).portid);
2393         if (IS_ERR(table)) {
2394                 NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TABLE]);
2395                 return PTR_ERR(table);
2396         }
2397
2398         chain = NULL;
2399         attr = nla[NFTA_CHAIN_NAME];
2400
2401         if (nla[NFTA_CHAIN_HANDLE]) {
2402                 handle = be64_to_cpu(nla_get_be64(nla[NFTA_CHAIN_HANDLE]));
2403                 chain = nft_chain_lookup_byhandle(table, handle, genmask);
2404                 if (IS_ERR(chain)) {
2405                         NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_HANDLE]);
2406                         return PTR_ERR(chain);
2407                 }
2408                 attr = nla[NFTA_CHAIN_HANDLE];
2409         } else if (nla[NFTA_CHAIN_NAME]) {
2410                 chain = nft_chain_lookup(net, table, attr, genmask);
2411                 if (IS_ERR(chain)) {
2412                         if (PTR_ERR(chain) != -ENOENT) {
2413                                 NL_SET_BAD_ATTR(extack, attr);
2414                                 return PTR_ERR(chain);
2415                         }
2416                         chain = NULL;
2417                 }
2418         } else if (!nla[NFTA_CHAIN_ID]) {
2419                 return -EINVAL;
2420         }
2421
2422         if (nla[NFTA_CHAIN_POLICY]) {
2423                 if (chain != NULL &&
2424                     !nft_is_base_chain(chain)) {
2425                         NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_POLICY]);
2426                         return -EOPNOTSUPP;
2427                 }
2428
2429                 if (chain == NULL &&
2430                     nla[NFTA_CHAIN_HOOK] == NULL) {
2431                         NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_POLICY]);
2432                         return -EOPNOTSUPP;
2433                 }
2434
2435                 policy = ntohl(nla_get_be32(nla[NFTA_CHAIN_POLICY]));
2436                 switch (policy) {
2437                 case NF_DROP:
2438                 case NF_ACCEPT:
2439                         break;
2440                 default:
2441                         return -EINVAL;
2442                 }
2443         }
2444
2445         if (nla[NFTA_CHAIN_FLAGS])
2446                 flags = ntohl(nla_get_be32(nla[NFTA_CHAIN_FLAGS]));
2447         else if (chain)
2448                 flags = chain->flags;
2449
2450         if (flags & ~NFT_CHAIN_FLAGS)
2451                 return -EOPNOTSUPP;
2452
2453         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla);
2454
2455         if (chain != NULL) {
2456                 if (info->nlh->nlmsg_flags & NLM_F_EXCL) {
2457                         NL_SET_BAD_ATTR(extack, attr);
2458                         return -EEXIST;
2459                 }
2460                 if (info->nlh->nlmsg_flags & NLM_F_REPLACE)
2461                         return -EOPNOTSUPP;
2462
2463                 flags |= chain->flags & NFT_CHAIN_BASE;
2464                 return nf_tables_updchain(&ctx, genmask, policy, flags, attr,
2465                                           extack);
2466         }
2467
2468         return nf_tables_addchain(&ctx, family, genmask, policy, flags, extack);
2469 }
2470
2471 static int nf_tables_delchain(struct sk_buff *skb, const struct nfnl_info *info,
2472                               const struct nlattr * const nla[])
2473 {
2474         struct netlink_ext_ack *extack = info->extack;
2475         u8 genmask = nft_genmask_next(info->net);
2476         u8 family = info->nfmsg->nfgen_family;
2477         struct net *net = info->net;
2478         const struct nlattr *attr;
2479         struct nft_table *table;
2480         struct nft_chain *chain;
2481         struct nft_rule *rule;
2482         struct nft_ctx ctx;
2483         u64 handle;
2484         u32 use;
2485         int err;
2486
2487         table = nft_table_lookup(net, nla[NFTA_CHAIN_TABLE], family, genmask,
2488                                  NETLINK_CB(skb).portid);
2489         if (IS_ERR(table)) {
2490                 NL_SET_BAD_ATTR(extack, nla[NFTA_CHAIN_TABLE]);
2491                 return PTR_ERR(table);
2492         }
2493
2494         if (nla[NFTA_CHAIN_HANDLE]) {
2495                 attr = nla[NFTA_CHAIN_HANDLE];
2496                 handle = be64_to_cpu(nla_get_be64(attr));
2497                 chain = nft_chain_lookup_byhandle(table, handle, genmask);
2498         } else {
2499                 attr = nla[NFTA_CHAIN_NAME];
2500                 chain = nft_chain_lookup(net, table, attr, genmask);
2501         }
2502         if (IS_ERR(chain)) {
2503                 NL_SET_BAD_ATTR(extack, attr);
2504                 return PTR_ERR(chain);
2505         }
2506
2507         if (info->nlh->nlmsg_flags & NLM_F_NONREC &&
2508             chain->use > 0)
2509                 return -EBUSY;
2510
2511         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla);
2512
2513         use = chain->use;
2514         list_for_each_entry(rule, &chain->rules, list) {
2515                 if (!nft_is_active_next(net, rule))
2516                         continue;
2517                 use--;
2518
2519                 err = nft_delrule(&ctx, rule);
2520                 if (err < 0)
2521                         return err;
2522         }
2523
2524         /* There are rules and elements that are still holding references to us,
2525          * we cannot do a recursive removal in this case.
2526          */
2527         if (use > 0) {
2528                 NL_SET_BAD_ATTR(extack, attr);
2529                 return -EBUSY;
2530         }
2531
2532         return nft_delchain(&ctx);
2533 }
2534
2535 /*
2536  * Expressions
2537  */
2538
2539 /**
2540  *      nft_register_expr - register nf_tables expr type
2541  *      @type: expr type
2542  *
2543  *      Registers the expr type for use with nf_tables. Returns zero on
2544  *      success or a negative errno code otherwise.
2545  */
2546 int nft_register_expr(struct nft_expr_type *type)
2547 {
2548         nfnl_lock(NFNL_SUBSYS_NFTABLES);
2549         if (type->family == NFPROTO_UNSPEC)
2550                 list_add_tail_rcu(&type->list, &nf_tables_expressions);
2551         else
2552                 list_add_rcu(&type->list, &nf_tables_expressions);
2553         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
2554         return 0;
2555 }
2556 EXPORT_SYMBOL_GPL(nft_register_expr);
2557
2558 /**
2559  *      nft_unregister_expr - unregister nf_tables expr type
2560  *      @type: expr type
2561  *
2562  *      Unregisters the expr typefor use with nf_tables.
2563  */
2564 void nft_unregister_expr(struct nft_expr_type *type)
2565 {
2566         nfnl_lock(NFNL_SUBSYS_NFTABLES);
2567         list_del_rcu(&type->list);
2568         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
2569 }
2570 EXPORT_SYMBOL_GPL(nft_unregister_expr);
2571
2572 static const struct nft_expr_type *__nft_expr_type_get(u8 family,
2573                                                        struct nlattr *nla)
2574 {
2575         const struct nft_expr_type *type, *candidate = NULL;
2576
2577         list_for_each_entry(type, &nf_tables_expressions, list) {
2578                 if (!nla_strcmp(nla, type->name)) {
2579                         if (!type->family && !candidate)
2580                                 candidate = type;
2581                         else if (type->family == family)
2582                                 candidate = type;
2583                 }
2584         }
2585         return candidate;
2586 }
2587
2588 #ifdef CONFIG_MODULES
2589 static int nft_expr_type_request_module(struct net *net, u8 family,
2590                                         struct nlattr *nla)
2591 {
2592         if (nft_request_module(net, "nft-expr-%u-%.*s", family,
2593                                nla_len(nla), (char *)nla_data(nla)) == -EAGAIN)
2594                 return -EAGAIN;
2595
2596         return 0;
2597 }
2598 #endif
2599
2600 static const struct nft_expr_type *nft_expr_type_get(struct net *net,
2601                                                      u8 family,
2602                                                      struct nlattr *nla)
2603 {
2604         const struct nft_expr_type *type;
2605
2606         if (nla == NULL)
2607                 return ERR_PTR(-EINVAL);
2608
2609         type = __nft_expr_type_get(family, nla);
2610         if (type != NULL && try_module_get(type->owner))
2611                 return type;
2612
2613         lockdep_nfnl_nft_mutex_not_held();
2614 #ifdef CONFIG_MODULES
2615         if (type == NULL) {
2616                 if (nft_expr_type_request_module(net, family, nla) == -EAGAIN)
2617                         return ERR_PTR(-EAGAIN);
2618
2619                 if (nft_request_module(net, "nft-expr-%.*s",
2620                                        nla_len(nla),
2621                                        (char *)nla_data(nla)) == -EAGAIN)
2622                         return ERR_PTR(-EAGAIN);
2623         }
2624 #endif
2625         return ERR_PTR(-ENOENT);
2626 }
2627
2628 static const struct nla_policy nft_expr_policy[NFTA_EXPR_MAX + 1] = {
2629         [NFTA_EXPR_NAME]        = { .type = NLA_STRING,
2630                                     .len = NFT_MODULE_AUTOLOAD_LIMIT },
2631         [NFTA_EXPR_DATA]        = { .type = NLA_NESTED },
2632 };
2633
2634 static int nf_tables_fill_expr_info(struct sk_buff *skb,
2635                                     const struct nft_expr *expr)
2636 {
2637         if (nla_put_string(skb, NFTA_EXPR_NAME, expr->ops->type->name))
2638                 goto nla_put_failure;
2639
2640         if (expr->ops->dump) {
2641                 struct nlattr *data = nla_nest_start_noflag(skb,
2642                                                             NFTA_EXPR_DATA);
2643                 if (data == NULL)
2644                         goto nla_put_failure;
2645                 if (expr->ops->dump(skb, expr) < 0)
2646                         goto nla_put_failure;
2647                 nla_nest_end(skb, data);
2648         }
2649
2650         return skb->len;
2651
2652 nla_put_failure:
2653         return -1;
2654 };
2655
2656 int nft_expr_dump(struct sk_buff *skb, unsigned int attr,
2657                   const struct nft_expr *expr)
2658 {
2659         struct nlattr *nest;
2660
2661         nest = nla_nest_start_noflag(skb, attr);
2662         if (!nest)
2663                 goto nla_put_failure;
2664         if (nf_tables_fill_expr_info(skb, expr) < 0)
2665                 goto nla_put_failure;
2666         nla_nest_end(skb, nest);
2667         return 0;
2668
2669 nla_put_failure:
2670         return -1;
2671 }
2672
2673 struct nft_expr_info {
2674         const struct nft_expr_ops       *ops;
2675         const struct nlattr             *attr;
2676         struct nlattr                   *tb[NFT_EXPR_MAXATTR + 1];
2677 };
2678
2679 static int nf_tables_expr_parse(const struct nft_ctx *ctx,
2680                                 const struct nlattr *nla,
2681                                 struct nft_expr_info *info)
2682 {
2683         const struct nft_expr_type *type;
2684         const struct nft_expr_ops *ops;
2685         struct nlattr *tb[NFTA_EXPR_MAX + 1];
2686         int err;
2687
2688         err = nla_parse_nested_deprecated(tb, NFTA_EXPR_MAX, nla,
2689                                           nft_expr_policy, NULL);
2690         if (err < 0)
2691                 return err;
2692
2693         type = nft_expr_type_get(ctx->net, ctx->family, tb[NFTA_EXPR_NAME]);
2694         if (IS_ERR(type))
2695                 return PTR_ERR(type);
2696
2697         if (tb[NFTA_EXPR_DATA]) {
2698                 err = nla_parse_nested_deprecated(info->tb, type->maxattr,
2699                                                   tb[NFTA_EXPR_DATA],
2700                                                   type->policy, NULL);
2701                 if (err < 0)
2702                         goto err1;
2703         } else
2704                 memset(info->tb, 0, sizeof(info->tb[0]) * (type->maxattr + 1));
2705
2706         if (type->select_ops != NULL) {
2707                 ops = type->select_ops(ctx,
2708                                        (const struct nlattr * const *)info->tb);
2709                 if (IS_ERR(ops)) {
2710                         err = PTR_ERR(ops);
2711 #ifdef CONFIG_MODULES
2712                         if (err == -EAGAIN)
2713                                 if (nft_expr_type_request_module(ctx->net,
2714                                                                  ctx->family,
2715                                                                  tb[NFTA_EXPR_NAME]) != -EAGAIN)
2716                                         err = -ENOENT;
2717 #endif
2718                         goto err1;
2719                 }
2720         } else
2721                 ops = type->ops;
2722
2723         info->attr = nla;
2724         info->ops = ops;
2725
2726         return 0;
2727
2728 err1:
2729         module_put(type->owner);
2730         return err;
2731 }
2732
2733 static int nf_tables_newexpr(const struct nft_ctx *ctx,
2734                              const struct nft_expr_info *expr_info,
2735                              struct nft_expr *expr)
2736 {
2737         const struct nft_expr_ops *ops = expr_info->ops;
2738         int err;
2739
2740         expr->ops = ops;
2741         if (ops->init) {
2742                 err = ops->init(ctx, expr, (const struct nlattr **)expr_info->tb);
2743                 if (err < 0)
2744                         goto err1;
2745         }
2746
2747         return 0;
2748 err1:
2749         expr->ops = NULL;
2750         return err;
2751 }
2752
2753 static void nf_tables_expr_destroy(const struct nft_ctx *ctx,
2754                                    struct nft_expr *expr)
2755 {
2756         const struct nft_expr_type *type = expr->ops->type;
2757
2758         if (expr->ops->destroy)
2759                 expr->ops->destroy(ctx, expr);
2760         module_put(type->owner);
2761 }
2762
2763 static struct nft_expr *nft_expr_init(const struct nft_ctx *ctx,
2764                                       const struct nlattr *nla)
2765 {
2766         struct nft_expr_info expr_info;
2767         struct nft_expr *expr;
2768         struct module *owner;
2769         int err;
2770
2771         err = nf_tables_expr_parse(ctx, nla, &expr_info);
2772         if (err < 0)
2773                 goto err1;
2774
2775         err = -ENOMEM;
2776         expr = kzalloc(expr_info.ops->size, GFP_KERNEL);
2777         if (expr == NULL)
2778                 goto err2;
2779
2780         err = nf_tables_newexpr(ctx, &expr_info, expr);
2781         if (err < 0)
2782                 goto err3;
2783
2784         return expr;
2785 err3:
2786         kfree(expr);
2787 err2:
2788         owner = expr_info.ops->type->owner;
2789         if (expr_info.ops->type->release_ops)
2790                 expr_info.ops->type->release_ops(expr_info.ops);
2791
2792         module_put(owner);
2793 err1:
2794         return ERR_PTR(err);
2795 }
2796
2797 int nft_expr_clone(struct nft_expr *dst, struct nft_expr *src)
2798 {
2799         int err;
2800
2801         if (src->ops->clone) {
2802                 dst->ops = src->ops;
2803                 err = src->ops->clone(dst, src);
2804                 if (err < 0)
2805                         return err;
2806         } else {
2807                 memcpy(dst, src, src->ops->size);
2808         }
2809
2810         __module_get(src->ops->type->owner);
2811
2812         return 0;
2813 }
2814
2815 void nft_expr_destroy(const struct nft_ctx *ctx, struct nft_expr *expr)
2816 {
2817         nf_tables_expr_destroy(ctx, expr);
2818         kfree(expr);
2819 }
2820
2821 /*
2822  * Rules
2823  */
2824
2825 static struct nft_rule *__nft_rule_lookup(const struct nft_chain *chain,
2826                                           u64 handle)
2827 {
2828         struct nft_rule *rule;
2829
2830         // FIXME: this sucks
2831         list_for_each_entry_rcu(rule, &chain->rules, list) {
2832                 if (handle == rule->handle)
2833                         return rule;
2834         }
2835
2836         return ERR_PTR(-ENOENT);
2837 }
2838
2839 static struct nft_rule *nft_rule_lookup(const struct nft_chain *chain,
2840                                         const struct nlattr *nla)
2841 {
2842         if (nla == NULL)
2843                 return ERR_PTR(-EINVAL);
2844
2845         return __nft_rule_lookup(chain, be64_to_cpu(nla_get_be64(nla)));
2846 }
2847
2848 static const struct nla_policy nft_rule_policy[NFTA_RULE_MAX + 1] = {
2849         [NFTA_RULE_TABLE]       = { .type = NLA_STRING,
2850                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
2851         [NFTA_RULE_CHAIN]       = { .type = NLA_STRING,
2852                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
2853         [NFTA_RULE_HANDLE]      = { .type = NLA_U64 },
2854         [NFTA_RULE_EXPRESSIONS] = { .type = NLA_NESTED },
2855         [NFTA_RULE_COMPAT]      = { .type = NLA_NESTED },
2856         [NFTA_RULE_POSITION]    = { .type = NLA_U64 },
2857         [NFTA_RULE_USERDATA]    = { .type = NLA_BINARY,
2858                                     .len = NFT_USERDATA_MAXLEN },
2859         [NFTA_RULE_ID]          = { .type = NLA_U32 },
2860         [NFTA_RULE_POSITION_ID] = { .type = NLA_U32 },
2861         [NFTA_RULE_CHAIN_ID]    = { .type = NLA_U32 },
2862 };
2863
2864 static int nf_tables_fill_rule_info(struct sk_buff *skb, struct net *net,
2865                                     u32 portid, u32 seq, int event,
2866                                     u32 flags, int family,
2867                                     const struct nft_table *table,
2868                                     const struct nft_chain *chain,
2869                                     const struct nft_rule *rule,
2870                                     const struct nft_rule *prule)
2871 {
2872         struct nlmsghdr *nlh;
2873         const struct nft_expr *expr, *next;
2874         struct nlattr *list;
2875         u16 type = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
2876
2877         nlh = nfnl_msg_put(skb, portid, seq, type, flags, family, NFNETLINK_V0,
2878                            nft_base_seq(net));
2879         if (!nlh)
2880                 goto nla_put_failure;
2881
2882         if (nla_put_string(skb, NFTA_RULE_TABLE, table->name))
2883                 goto nla_put_failure;
2884         if (nla_put_string(skb, NFTA_RULE_CHAIN, chain->name))
2885                 goto nla_put_failure;
2886         if (nla_put_be64(skb, NFTA_RULE_HANDLE, cpu_to_be64(rule->handle),
2887                          NFTA_RULE_PAD))
2888                 goto nla_put_failure;
2889
2890         if (event != NFT_MSG_DELRULE && prule) {
2891                 if (nla_put_be64(skb, NFTA_RULE_POSITION,
2892                                  cpu_to_be64(prule->handle),
2893                                  NFTA_RULE_PAD))
2894                         goto nla_put_failure;
2895         }
2896
2897         if (chain->flags & NFT_CHAIN_HW_OFFLOAD)
2898                 nft_flow_rule_stats(chain, rule);
2899
2900         list = nla_nest_start_noflag(skb, NFTA_RULE_EXPRESSIONS);
2901         if (list == NULL)
2902                 goto nla_put_failure;
2903         nft_rule_for_each_expr(expr, next, rule) {
2904                 if (nft_expr_dump(skb, NFTA_LIST_ELEM, expr) < 0)
2905                         goto nla_put_failure;
2906         }
2907         nla_nest_end(skb, list);
2908
2909         if (rule->udata) {
2910                 struct nft_userdata *udata = nft_userdata(rule);
2911                 if (nla_put(skb, NFTA_RULE_USERDATA, udata->len + 1,
2912                             udata->data) < 0)
2913                         goto nla_put_failure;
2914         }
2915
2916         nlmsg_end(skb, nlh);
2917         return 0;
2918
2919 nla_put_failure:
2920         nlmsg_trim(skb, nlh);
2921         return -1;
2922 }
2923
2924 static void nf_tables_rule_notify(const struct nft_ctx *ctx,
2925                                   const struct nft_rule *rule, int event)
2926 {
2927         struct nftables_pernet *nft_net = nft_pernet(ctx->net);
2928         struct sk_buff *skb;
2929         int err;
2930
2931         if (!ctx->report &&
2932             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
2933                 return;
2934
2935         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
2936         if (skb == NULL)
2937                 goto err;
2938
2939         err = nf_tables_fill_rule_info(skb, ctx->net, ctx->portid, ctx->seq,
2940                                        event, 0, ctx->family, ctx->table,
2941                                        ctx->chain, rule, NULL);
2942         if (err < 0) {
2943                 kfree_skb(skb);
2944                 goto err;
2945         }
2946
2947         nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);
2948         return;
2949 err:
2950         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
2951 }
2952
2953 struct nft_rule_dump_ctx {
2954         char *table;
2955         char *chain;
2956 };
2957
2958 static int __nf_tables_dump_rules(struct sk_buff *skb,
2959                                   unsigned int *idx,
2960                                   struct netlink_callback *cb,
2961                                   const struct nft_table *table,
2962                                   const struct nft_chain *chain)
2963 {
2964         struct net *net = sock_net(skb->sk);
2965         const struct nft_rule *rule, *prule;
2966         unsigned int s_idx = cb->args[0];
2967
2968         prule = NULL;
2969         list_for_each_entry_rcu(rule, &chain->rules, list) {
2970                 if (!nft_is_active(net, rule))
2971                         goto cont_skip;
2972                 if (*idx < s_idx)
2973                         goto cont;
2974                 if (*idx > s_idx) {
2975                         memset(&cb->args[1], 0,
2976                                         sizeof(cb->args) - sizeof(cb->args[0]));
2977                 }
2978                 if (nf_tables_fill_rule_info(skb, net, NETLINK_CB(cb->skb).portid,
2979                                         cb->nlh->nlmsg_seq,
2980                                         NFT_MSG_NEWRULE,
2981                                         NLM_F_MULTI | NLM_F_APPEND,
2982                                         table->family,
2983                                         table, chain, rule, prule) < 0)
2984                         return 1;
2985
2986                 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2987 cont:
2988                 prule = rule;
2989 cont_skip:
2990                 (*idx)++;
2991         }
2992         return 0;
2993 }
2994
2995 static int nf_tables_dump_rules(struct sk_buff *skb,
2996                                 struct netlink_callback *cb)
2997 {
2998         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
2999         const struct nft_rule_dump_ctx *ctx = cb->data;
3000         struct nft_table *table;
3001         const struct nft_chain *chain;
3002         unsigned int idx = 0;
3003         struct net *net = sock_net(skb->sk);
3004         int family = nfmsg->nfgen_family;
3005         struct nftables_pernet *nft_net;
3006
3007         rcu_read_lock();
3008         nft_net = nft_pernet(net);
3009         cb->seq = nft_net->base_seq;
3010
3011         list_for_each_entry_rcu(table, &nft_net->tables, list) {
3012                 if (family != NFPROTO_UNSPEC && family != table->family)
3013                         continue;
3014
3015                 if (ctx && ctx->table && strcmp(ctx->table, table->name) != 0)
3016                         continue;
3017
3018                 if (ctx && ctx->table && ctx->chain) {
3019                         struct rhlist_head *list, *tmp;
3020
3021                         list = rhltable_lookup(&table->chains_ht, ctx->chain,
3022                                                nft_chain_ht_params);
3023                         if (!list)
3024                                 goto done;
3025
3026                         rhl_for_each_entry_rcu(chain, tmp, list, rhlhead) {
3027                                 if (!nft_is_active(net, chain))
3028                                         continue;
3029                                 __nf_tables_dump_rules(skb, &idx,
3030                                                        cb, table, chain);
3031                                 break;
3032                         }
3033                         goto done;
3034                 }
3035
3036                 list_for_each_entry_rcu(chain, &table->chains, list) {
3037                         if (__nf_tables_dump_rules(skb, &idx, cb, table, chain))
3038                                 goto done;
3039                 }
3040
3041                 if (ctx && ctx->table)
3042                         break;
3043         }
3044 done:
3045         rcu_read_unlock();
3046
3047         cb->args[0] = idx;
3048         return skb->len;
3049 }
3050
3051 static int nf_tables_dump_rules_start(struct netlink_callback *cb)
3052 {
3053         const struct nlattr * const *nla = cb->data;
3054         struct nft_rule_dump_ctx *ctx = NULL;
3055
3056         if (nla[NFTA_RULE_TABLE] || nla[NFTA_RULE_CHAIN]) {
3057                 ctx = kzalloc(sizeof(*ctx), GFP_ATOMIC);
3058                 if (!ctx)
3059                         return -ENOMEM;
3060
3061                 if (nla[NFTA_RULE_TABLE]) {
3062                         ctx->table = nla_strdup(nla[NFTA_RULE_TABLE],
3063                                                         GFP_ATOMIC);
3064                         if (!ctx->table) {
3065                                 kfree(ctx);
3066                                 return -ENOMEM;
3067                         }
3068                 }
3069                 if (nla[NFTA_RULE_CHAIN]) {
3070                         ctx->chain = nla_strdup(nla[NFTA_RULE_CHAIN],
3071                                                 GFP_ATOMIC);
3072                         if (!ctx->chain) {
3073                                 kfree(ctx->table);
3074                                 kfree(ctx);
3075                                 return -ENOMEM;
3076                         }
3077                 }
3078         }
3079
3080         cb->data = ctx;
3081         return 0;
3082 }
3083
3084 static int nf_tables_dump_rules_done(struct netlink_callback *cb)
3085 {
3086         struct nft_rule_dump_ctx *ctx = cb->data;
3087
3088         if (ctx) {
3089                 kfree(ctx->table);
3090                 kfree(ctx->chain);
3091                 kfree(ctx);
3092         }
3093         return 0;
3094 }
3095
3096 /* called with rcu_read_lock held */
3097 static int nf_tables_getrule(struct sk_buff *skb, const struct nfnl_info *info,
3098                              const struct nlattr * const nla[])
3099 {
3100         struct netlink_ext_ack *extack = info->extack;
3101         u8 genmask = nft_genmask_cur(info->net);
3102         u8 family = info->nfmsg->nfgen_family;
3103         const struct nft_chain *chain;
3104         const struct nft_rule *rule;
3105         struct net *net = info->net;
3106         struct nft_table *table;
3107         struct sk_buff *skb2;
3108         int err;
3109
3110         if (info->nlh->nlmsg_flags & NLM_F_DUMP) {
3111                 struct netlink_dump_control c = {
3112                         .start= nf_tables_dump_rules_start,
3113                         .dump = nf_tables_dump_rules,
3114                         .done = nf_tables_dump_rules_done,
3115                         .module = THIS_MODULE,
3116                         .data = (void *)nla,
3117                 };
3118
3119                 return nft_netlink_dump_start_rcu(info->sk, skb, info->nlh, &c);
3120         }
3121
3122         table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask, 0);
3123         if (IS_ERR(table)) {
3124                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_TABLE]);
3125                 return PTR_ERR(table);
3126         }
3127
3128         chain = nft_chain_lookup(net, table, nla[NFTA_RULE_CHAIN], genmask);
3129         if (IS_ERR(chain)) {
3130                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_CHAIN]);
3131                 return PTR_ERR(chain);
3132         }
3133
3134         rule = nft_rule_lookup(chain, nla[NFTA_RULE_HANDLE]);
3135         if (IS_ERR(rule)) {
3136                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_HANDLE]);
3137                 return PTR_ERR(rule);
3138         }
3139
3140         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
3141         if (!skb2)
3142                 return -ENOMEM;
3143
3144         err = nf_tables_fill_rule_info(skb2, net, NETLINK_CB(skb).portid,
3145                                        info->nlh->nlmsg_seq, NFT_MSG_NEWRULE, 0,
3146                                        family, table, chain, rule, NULL);
3147         if (err < 0)
3148                 goto err_fill_rule_info;
3149
3150         return nfnetlink_unicast(skb2, net, NETLINK_CB(skb).portid);
3151
3152 err_fill_rule_info:
3153         kfree_skb(skb2);
3154         return err;
3155 }
3156
3157 static void nf_tables_rule_destroy(const struct nft_ctx *ctx,
3158                                    struct nft_rule *rule)
3159 {
3160         struct nft_expr *expr, *next;
3161
3162         /*
3163          * Careful: some expressions might not be initialized in case this
3164          * is called on error from nf_tables_newrule().
3165          */
3166         expr = nft_expr_first(rule);
3167         while (nft_expr_more(rule, expr)) {
3168                 next = nft_expr_next(expr);
3169                 nf_tables_expr_destroy(ctx, expr);
3170                 expr = next;
3171         }
3172         kfree(rule);
3173 }
3174
3175 void nf_tables_rule_release(const struct nft_ctx *ctx, struct nft_rule *rule)
3176 {
3177         nft_rule_expr_deactivate(ctx, rule, NFT_TRANS_RELEASE);
3178         nf_tables_rule_destroy(ctx, rule);
3179 }
3180
3181 int nft_chain_validate(const struct nft_ctx *ctx, const struct nft_chain *chain)
3182 {
3183         struct nft_expr *expr, *last;
3184         const struct nft_data *data;
3185         struct nft_rule *rule;
3186         int err;
3187
3188         if (ctx->level == NFT_JUMP_STACK_SIZE)
3189                 return -EMLINK;
3190
3191         list_for_each_entry(rule, &chain->rules, list) {
3192                 if (!nft_is_active_next(ctx->net, rule))
3193                         continue;
3194
3195                 nft_rule_for_each_expr(expr, last, rule) {
3196                         if (!expr->ops->validate)
3197                                 continue;
3198
3199                         err = expr->ops->validate(ctx, expr, &data);
3200                         if (err < 0)
3201                                 return err;
3202                 }
3203         }
3204
3205         return 0;
3206 }
3207 EXPORT_SYMBOL_GPL(nft_chain_validate);
3208
3209 static int nft_table_validate(struct net *net, const struct nft_table *table)
3210 {
3211         struct nft_chain *chain;
3212         struct nft_ctx ctx = {
3213                 .net    = net,
3214                 .family = table->family,
3215         };
3216         int err;
3217
3218         list_for_each_entry(chain, &table->chains, list) {
3219                 if (!nft_is_base_chain(chain))
3220                         continue;
3221
3222                 ctx.chain = chain;
3223                 err = nft_chain_validate(&ctx, chain);
3224                 if (err < 0)
3225                         return err;
3226         }
3227
3228         return 0;
3229 }
3230
3231 static struct nft_rule *nft_rule_lookup_byid(const struct net *net,
3232                                              const struct nlattr *nla);
3233
3234 #define NFT_RULE_MAXEXPRS       128
3235
3236 static int nf_tables_newrule(struct sk_buff *skb, const struct nfnl_info *info,
3237                              const struct nlattr * const nla[])
3238 {
3239         struct nftables_pernet *nft_net = nft_pernet(info->net);
3240         struct netlink_ext_ack *extack = info->extack;
3241         unsigned int size, i, n, ulen = 0, usize = 0;
3242         u8 genmask = nft_genmask_next(info->net);
3243         struct nft_rule *rule, *old_rule = NULL;
3244         struct nft_expr_info *expr_info = NULL;
3245         u8 family = info->nfmsg->nfgen_family;
3246         struct nft_flow_rule *flow = NULL;
3247         struct net *net = info->net;
3248         struct nft_userdata *udata;
3249         struct nft_table *table;
3250         struct nft_chain *chain;
3251         struct nft_trans *trans;
3252         u64 handle, pos_handle;
3253         struct nft_expr *expr;
3254         struct nft_ctx ctx;
3255         struct nlattr *tmp;
3256         int err, rem;
3257
3258         lockdep_assert_held(&nft_net->commit_mutex);
3259
3260         table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask,
3261                                  NETLINK_CB(skb).portid);
3262         if (IS_ERR(table)) {
3263                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_TABLE]);
3264                 return PTR_ERR(table);
3265         }
3266
3267         if (nla[NFTA_RULE_CHAIN]) {
3268                 chain = nft_chain_lookup(net, table, nla[NFTA_RULE_CHAIN],
3269                                          genmask);
3270                 if (IS_ERR(chain)) {
3271                         NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_CHAIN]);
3272                         return PTR_ERR(chain);
3273                 }
3274                 if (nft_chain_is_bound(chain))
3275                         return -EOPNOTSUPP;
3276
3277         } else if (nla[NFTA_RULE_CHAIN_ID]) {
3278                 chain = nft_chain_lookup_byid(net, nla[NFTA_RULE_CHAIN_ID]);
3279                 if (IS_ERR(chain)) {
3280                         NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_CHAIN_ID]);
3281                         return PTR_ERR(chain);
3282                 }
3283         } else {
3284                 return -EINVAL;
3285         }
3286
3287         if (nla[NFTA_RULE_HANDLE]) {
3288                 handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_HANDLE]));
3289                 rule = __nft_rule_lookup(chain, handle);
3290                 if (IS_ERR(rule)) {
3291                         NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_HANDLE]);
3292                         return PTR_ERR(rule);
3293                 }
3294
3295                 if (info->nlh->nlmsg_flags & NLM_F_EXCL) {
3296                         NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_HANDLE]);
3297                         return -EEXIST;
3298                 }
3299                 if (info->nlh->nlmsg_flags & NLM_F_REPLACE)
3300                         old_rule = rule;
3301                 else
3302                         return -EOPNOTSUPP;
3303         } else {
3304                 if (!(info->nlh->nlmsg_flags & NLM_F_CREATE) ||
3305                     info->nlh->nlmsg_flags & NLM_F_REPLACE)
3306                         return -EINVAL;
3307                 handle = nf_tables_alloc_handle(table);
3308
3309                 if (chain->use == UINT_MAX)
3310                         return -EOVERFLOW;
3311
3312                 if (nla[NFTA_RULE_POSITION]) {
3313                         pos_handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_POSITION]));
3314                         old_rule = __nft_rule_lookup(chain, pos_handle);
3315                         if (IS_ERR(old_rule)) {
3316                                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_POSITION]);
3317                                 return PTR_ERR(old_rule);
3318                         }
3319                 } else if (nla[NFTA_RULE_POSITION_ID]) {
3320                         old_rule = nft_rule_lookup_byid(net, nla[NFTA_RULE_POSITION_ID]);
3321                         if (IS_ERR(old_rule)) {
3322                                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_POSITION_ID]);
3323                                 return PTR_ERR(old_rule);
3324                         }
3325                 }
3326         }
3327
3328         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla);
3329
3330         n = 0;
3331         size = 0;
3332         if (nla[NFTA_RULE_EXPRESSIONS]) {
3333                 expr_info = kvmalloc_array(NFT_RULE_MAXEXPRS,
3334                                            sizeof(struct nft_expr_info),
3335                                            GFP_KERNEL);
3336                 if (!expr_info)
3337                         return -ENOMEM;
3338
3339                 nla_for_each_nested(tmp, nla[NFTA_RULE_EXPRESSIONS], rem) {
3340                         err = -EINVAL;
3341                         if (nla_type(tmp) != NFTA_LIST_ELEM)
3342                                 goto err_release_expr;
3343                         if (n == NFT_RULE_MAXEXPRS)
3344                                 goto err_release_expr;
3345                         err = nf_tables_expr_parse(&ctx, tmp, &expr_info[n]);
3346                         if (err < 0) {
3347                                 NL_SET_BAD_ATTR(extack, tmp);
3348                                 goto err_release_expr;
3349                         }
3350                         size += expr_info[n].ops->size;
3351                         n++;
3352                 }
3353         }
3354         /* Check for overflow of dlen field */
3355         err = -EFBIG;
3356         if (size >= 1 << 12)
3357                 goto err_release_expr;
3358
3359         if (nla[NFTA_RULE_USERDATA]) {
3360                 ulen = nla_len(nla[NFTA_RULE_USERDATA]);
3361                 if (ulen > 0)
3362                         usize = sizeof(struct nft_userdata) + ulen;
3363         }
3364
3365         err = -ENOMEM;
3366         rule = kzalloc(sizeof(*rule) + size + usize, GFP_KERNEL);
3367         if (rule == NULL)
3368                 goto err_release_expr;
3369
3370         nft_activate_next(net, rule);
3371
3372         rule->handle = handle;
3373         rule->dlen   = size;
3374         rule->udata  = ulen ? 1 : 0;
3375
3376         if (ulen) {
3377                 udata = nft_userdata(rule);
3378                 udata->len = ulen - 1;
3379                 nla_memcpy(udata->data, nla[NFTA_RULE_USERDATA], ulen);
3380         }
3381
3382         expr = nft_expr_first(rule);
3383         for (i = 0; i < n; i++) {
3384                 err = nf_tables_newexpr(&ctx, &expr_info[i], expr);
3385                 if (err < 0) {
3386                         NL_SET_BAD_ATTR(extack, expr_info[i].attr);
3387                         goto err_release_rule;
3388                 }
3389
3390                 if (expr_info[i].ops->validate)
3391                         nft_validate_state_update(net, NFT_VALIDATE_NEED);
3392
3393                 expr_info[i].ops = NULL;
3394                 expr = nft_expr_next(expr);
3395         }
3396
3397         if (chain->flags & NFT_CHAIN_HW_OFFLOAD) {
3398                 flow = nft_flow_rule_create(net, rule);
3399                 if (IS_ERR(flow)) {
3400                         err = PTR_ERR(flow);
3401                         goto err_release_rule;
3402                 }
3403         }
3404
3405         if (info->nlh->nlmsg_flags & NLM_F_REPLACE) {
3406                 trans = nft_trans_rule_add(&ctx, NFT_MSG_NEWRULE, rule);
3407                 if (trans == NULL) {
3408                         err = -ENOMEM;
3409                         goto err_destroy_flow_rule;
3410                 }
3411                 err = nft_delrule(&ctx, old_rule);
3412                 if (err < 0) {
3413                         nft_trans_destroy(trans);
3414                         goto err_destroy_flow_rule;
3415                 }
3416
3417                 list_add_tail_rcu(&rule->list, &old_rule->list);
3418         } else {
3419                 trans = nft_trans_rule_add(&ctx, NFT_MSG_NEWRULE, rule);
3420                 if (!trans) {
3421                         err = -ENOMEM;
3422                         goto err_destroy_flow_rule;
3423                 }
3424
3425                 if (info->nlh->nlmsg_flags & NLM_F_APPEND) {
3426                         if (old_rule)
3427                                 list_add_rcu(&rule->list, &old_rule->list);
3428                         else
3429                                 list_add_tail_rcu(&rule->list, &chain->rules);
3430                  } else {
3431                         if (old_rule)
3432                                 list_add_tail_rcu(&rule->list, &old_rule->list);
3433                         else
3434                                 list_add_rcu(&rule->list, &chain->rules);
3435                 }
3436         }
3437         kvfree(expr_info);
3438         chain->use++;
3439
3440         if (flow)
3441                 nft_trans_flow_rule(trans) = flow;
3442
3443         if (nft_net->validate_state == NFT_VALIDATE_DO)
3444                 return nft_table_validate(net, table);
3445
3446         return 0;
3447
3448 err_destroy_flow_rule:
3449         nft_flow_rule_destroy(flow);
3450 err_release_rule:
3451         nf_tables_rule_release(&ctx, rule);
3452 err_release_expr:
3453         for (i = 0; i < n; i++) {
3454                 if (expr_info[i].ops) {
3455                         module_put(expr_info[i].ops->type->owner);
3456                         if (expr_info[i].ops->type->release_ops)
3457                                 expr_info[i].ops->type->release_ops(expr_info[i].ops);
3458                 }
3459         }
3460         kvfree(expr_info);
3461
3462         return err;
3463 }
3464
3465 static struct nft_rule *nft_rule_lookup_byid(const struct net *net,
3466                                              const struct nlattr *nla)
3467 {
3468         struct nftables_pernet *nft_net = nft_pernet(net);
3469         u32 id = ntohl(nla_get_be32(nla));
3470         struct nft_trans *trans;
3471
3472         list_for_each_entry(trans, &nft_net->commit_list, list) {
3473                 struct nft_rule *rule = nft_trans_rule(trans);
3474
3475                 if (trans->msg_type == NFT_MSG_NEWRULE &&
3476                     id == nft_trans_rule_id(trans))
3477                         return rule;
3478         }
3479         return ERR_PTR(-ENOENT);
3480 }
3481
3482 static int nf_tables_delrule(struct sk_buff *skb, const struct nfnl_info *info,
3483                              const struct nlattr * const nla[])
3484 {
3485         struct netlink_ext_ack *extack = info->extack;
3486         u8 genmask = nft_genmask_next(info->net);
3487         u8 family = info->nfmsg->nfgen_family;
3488         struct nft_chain *chain = NULL;
3489         struct net *net = info->net;
3490         struct nft_table *table;
3491         struct nft_rule *rule;
3492         struct nft_ctx ctx;
3493         int err = 0;
3494
3495         table = nft_table_lookup(net, nla[NFTA_RULE_TABLE], family, genmask,
3496                                  NETLINK_CB(skb).portid);
3497         if (IS_ERR(table)) {
3498                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_TABLE]);
3499                 return PTR_ERR(table);
3500         }
3501
3502         if (nla[NFTA_RULE_CHAIN]) {
3503                 chain = nft_chain_lookup(net, table, nla[NFTA_RULE_CHAIN],
3504                                          genmask);
3505                 if (IS_ERR(chain)) {
3506                         NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_CHAIN]);
3507                         return PTR_ERR(chain);
3508                 }
3509                 if (nft_chain_is_bound(chain))
3510                         return -EOPNOTSUPP;
3511         }
3512
3513         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, chain, nla);
3514
3515         if (chain) {
3516                 if (nla[NFTA_RULE_HANDLE]) {
3517                         rule = nft_rule_lookup(chain, nla[NFTA_RULE_HANDLE]);
3518                         if (IS_ERR(rule)) {
3519                                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_HANDLE]);
3520                                 return PTR_ERR(rule);
3521                         }
3522
3523                         err = nft_delrule(&ctx, rule);
3524                 } else if (nla[NFTA_RULE_ID]) {
3525                         rule = nft_rule_lookup_byid(net, nla[NFTA_RULE_ID]);
3526                         if (IS_ERR(rule)) {
3527                                 NL_SET_BAD_ATTR(extack, nla[NFTA_RULE_ID]);
3528                                 return PTR_ERR(rule);
3529                         }
3530
3531                         err = nft_delrule(&ctx, rule);
3532                 } else {
3533                         err = nft_delrule_by_chain(&ctx);
3534                 }
3535         } else {
3536                 list_for_each_entry(chain, &table->chains, list) {
3537                         if (!nft_is_active_next(net, chain))
3538                                 continue;
3539
3540                         ctx.chain = chain;
3541                         err = nft_delrule_by_chain(&ctx);
3542                         if (err < 0)
3543                                 break;
3544                 }
3545         }
3546
3547         return err;
3548 }
3549
3550 /*
3551  * Sets
3552  */
3553 static const struct nft_set_type *nft_set_types[] = {
3554         &nft_set_hash_fast_type,
3555         &nft_set_hash_type,
3556         &nft_set_rhash_type,
3557         &nft_set_bitmap_type,
3558         &nft_set_rbtree_type,
3559 #if defined(CONFIG_X86_64) && !defined(CONFIG_UML)
3560         &nft_set_pipapo_avx2_type,
3561 #endif
3562         &nft_set_pipapo_type,
3563 };
3564
3565 #define NFT_SET_FEATURES        (NFT_SET_INTERVAL | NFT_SET_MAP | \
3566                                  NFT_SET_TIMEOUT | NFT_SET_OBJECT | \
3567                                  NFT_SET_EVAL)
3568
3569 static bool nft_set_ops_candidate(const struct nft_set_type *type, u32 flags)
3570 {
3571         return (flags & type->features) == (flags & NFT_SET_FEATURES);
3572 }
3573
3574 /*
3575  * Select a set implementation based on the data characteristics and the
3576  * given policy. The total memory use might not be known if no size is
3577  * given, in that case the amount of memory per element is used.
3578  */
3579 static const struct nft_set_ops *
3580 nft_select_set_ops(const struct nft_ctx *ctx,
3581                    const struct nlattr * const nla[],
3582                    const struct nft_set_desc *desc,
3583                    enum nft_set_policies policy)
3584 {
3585         struct nftables_pernet *nft_net = nft_pernet(ctx->net);
3586         const struct nft_set_ops *ops, *bops;
3587         struct nft_set_estimate est, best;
3588         const struct nft_set_type *type;
3589         u32 flags = 0;
3590         int i;
3591
3592         lockdep_assert_held(&nft_net->commit_mutex);
3593         lockdep_nfnl_nft_mutex_not_held();
3594
3595         if (nla[NFTA_SET_FLAGS] != NULL)
3596                 flags = ntohl(nla_get_be32(nla[NFTA_SET_FLAGS]));
3597
3598         bops        = NULL;
3599         best.size   = ~0;
3600         best.lookup = ~0;
3601         best.space  = ~0;
3602
3603         for (i = 0; i < ARRAY_SIZE(nft_set_types); i++) {
3604                 type = nft_set_types[i];
3605                 ops = &type->ops;
3606
3607                 if (!nft_set_ops_candidate(type, flags))
3608                         continue;
3609                 if (!ops->estimate(desc, flags, &est))
3610                         continue;
3611
3612                 switch (policy) {
3613                 case NFT_SET_POL_PERFORMANCE:
3614                         if (est.lookup < best.lookup)
3615                                 break;
3616                         if (est.lookup == best.lookup &&
3617                             est.space < best.space)
3618                                 break;
3619                         continue;
3620                 case NFT_SET_POL_MEMORY:
3621                         if (!desc->size) {
3622                                 if (est.space < best.space)
3623                                         break;
3624                                 if (est.space == best.space &&
3625                                     est.lookup < best.lookup)
3626                                         break;
3627                         } else if (est.size < best.size || !bops) {
3628                                 break;
3629                         }
3630                         continue;
3631                 default:
3632                         break;
3633                 }
3634
3635                 bops = ops;
3636                 best = est;
3637         }
3638
3639         if (bops != NULL)
3640                 return bops;
3641
3642         return ERR_PTR(-EOPNOTSUPP);
3643 }
3644
3645 static const struct nla_policy nft_set_policy[NFTA_SET_MAX + 1] = {
3646         [NFTA_SET_TABLE]                = { .type = NLA_STRING,
3647                                             .len = NFT_TABLE_MAXNAMELEN - 1 },
3648         [NFTA_SET_NAME]                 = { .type = NLA_STRING,
3649                                             .len = NFT_SET_MAXNAMELEN - 1 },
3650         [NFTA_SET_FLAGS]                = { .type = NLA_U32 },
3651         [NFTA_SET_KEY_TYPE]             = { .type = NLA_U32 },
3652         [NFTA_SET_KEY_LEN]              = { .type = NLA_U32 },
3653         [NFTA_SET_DATA_TYPE]            = { .type = NLA_U32 },
3654         [NFTA_SET_DATA_LEN]             = { .type = NLA_U32 },
3655         [NFTA_SET_POLICY]               = { .type = NLA_U32 },
3656         [NFTA_SET_DESC]                 = { .type = NLA_NESTED },
3657         [NFTA_SET_ID]                   = { .type = NLA_U32 },
3658         [NFTA_SET_TIMEOUT]              = { .type = NLA_U64 },
3659         [NFTA_SET_GC_INTERVAL]          = { .type = NLA_U32 },
3660         [NFTA_SET_USERDATA]             = { .type = NLA_BINARY,
3661                                             .len  = NFT_USERDATA_MAXLEN },
3662         [NFTA_SET_OBJ_TYPE]             = { .type = NLA_U32 },
3663         [NFTA_SET_HANDLE]               = { .type = NLA_U64 },
3664         [NFTA_SET_EXPR]                 = { .type = NLA_NESTED },
3665         [NFTA_SET_EXPRESSIONS]          = { .type = NLA_NESTED },
3666 };
3667
3668 static const struct nla_policy nft_set_desc_policy[NFTA_SET_DESC_MAX + 1] = {
3669         [NFTA_SET_DESC_SIZE]            = { .type = NLA_U32 },
3670         [NFTA_SET_DESC_CONCAT]          = { .type = NLA_NESTED },
3671 };
3672
3673 static struct nft_set *nft_set_lookup(const struct nft_table *table,
3674                                       const struct nlattr *nla, u8 genmask)
3675 {
3676         struct nft_set *set;
3677
3678         if (nla == NULL)
3679                 return ERR_PTR(-EINVAL);
3680
3681         list_for_each_entry_rcu(set, &table->sets, list) {
3682                 if (!nla_strcmp(nla, set->name) &&
3683                     nft_active_genmask(set, genmask))
3684                         return set;
3685         }
3686         return ERR_PTR(-ENOENT);
3687 }
3688
3689 static struct nft_set *nft_set_lookup_byhandle(const struct nft_table *table,
3690                                                const struct nlattr *nla,
3691                                                u8 genmask)
3692 {
3693         struct nft_set *set;
3694
3695         list_for_each_entry(set, &table->sets, list) {
3696                 if (be64_to_cpu(nla_get_be64(nla)) == set->handle &&
3697                     nft_active_genmask(set, genmask))
3698                         return set;
3699         }
3700         return ERR_PTR(-ENOENT);
3701 }
3702
3703 static struct nft_set *nft_set_lookup_byid(const struct net *net,
3704                                            const struct nlattr *nla, u8 genmask)
3705 {
3706         struct nftables_pernet *nft_net = nft_pernet(net);
3707         u32 id = ntohl(nla_get_be32(nla));
3708         struct nft_trans *trans;
3709
3710         list_for_each_entry(trans, &nft_net->commit_list, list) {
3711                 if (trans->msg_type == NFT_MSG_NEWSET) {
3712                         struct nft_set *set = nft_trans_set(trans);
3713
3714                         if (id == nft_trans_set_id(trans) &&
3715                             nft_active_genmask(set, genmask))
3716                                 return set;
3717                 }
3718         }
3719         return ERR_PTR(-ENOENT);
3720 }
3721
3722 struct nft_set *nft_set_lookup_global(const struct net *net,
3723                                       const struct nft_table *table,
3724                                       const struct nlattr *nla_set_name,
3725                                       const struct nlattr *nla_set_id,
3726                                       u8 genmask)
3727 {
3728         struct nft_set *set;
3729
3730         set = nft_set_lookup(table, nla_set_name, genmask);
3731         if (IS_ERR(set)) {
3732                 if (!nla_set_id)
3733                         return set;
3734
3735                 set = nft_set_lookup_byid(net, nla_set_id, genmask);
3736         }
3737         return set;
3738 }
3739 EXPORT_SYMBOL_GPL(nft_set_lookup_global);
3740
3741 static int nf_tables_set_alloc_name(struct nft_ctx *ctx, struct nft_set *set,
3742                                     const char *name)
3743 {
3744         const struct nft_set *i;
3745         const char *p;
3746         unsigned long *inuse;
3747         unsigned int n = 0, min = 0;
3748
3749         p = strchr(name, '%');
3750         if (p != NULL) {
3751                 if (p[1] != 'd' || strchr(p + 2, '%'))
3752                         return -EINVAL;
3753
3754                 inuse = (unsigned long *)get_zeroed_page(GFP_KERNEL);
3755                 if (inuse == NULL)
3756                         return -ENOMEM;
3757 cont:
3758                 list_for_each_entry(i, &ctx->table->sets, list) {
3759                         int tmp;
3760
3761                         if (!nft_is_active_next(ctx->net, set))
3762                                 continue;
3763                         if (!sscanf(i->name, name, &tmp))
3764                                 continue;
3765                         if (tmp < min || tmp >= min + BITS_PER_BYTE * PAGE_SIZE)
3766                                 continue;
3767
3768                         set_bit(tmp - min, inuse);
3769                 }
3770
3771                 n = find_first_zero_bit(inuse, BITS_PER_BYTE * PAGE_SIZE);
3772                 if (n >= BITS_PER_BYTE * PAGE_SIZE) {
3773                         min += BITS_PER_BYTE * PAGE_SIZE;
3774                         memset(inuse, 0, PAGE_SIZE);
3775                         goto cont;
3776                 }
3777                 free_page((unsigned long)inuse);
3778         }
3779
3780         set->name = kasprintf(GFP_KERNEL, name, min + n);
3781         if (!set->name)
3782                 return -ENOMEM;
3783
3784         list_for_each_entry(i, &ctx->table->sets, list) {
3785                 if (!nft_is_active_next(ctx->net, i))
3786                         continue;
3787                 if (!strcmp(set->name, i->name)) {
3788                         kfree(set->name);
3789                         set->name = NULL;
3790                         return -ENFILE;
3791                 }
3792         }
3793         return 0;
3794 }
3795
3796 int nf_msecs_to_jiffies64(const struct nlattr *nla, u64 *result)
3797 {
3798         u64 ms = be64_to_cpu(nla_get_be64(nla));
3799         u64 max = (u64)(~((u64)0));
3800
3801         max = div_u64(max, NSEC_PER_MSEC);
3802         if (ms >= max)
3803                 return -ERANGE;
3804
3805         ms *= NSEC_PER_MSEC;
3806         *result = nsecs_to_jiffies64(ms);
3807         return 0;
3808 }
3809
3810 __be64 nf_jiffies64_to_msecs(u64 input)
3811 {
3812         return cpu_to_be64(jiffies64_to_msecs(input));
3813 }
3814
3815 static int nf_tables_fill_set_concat(struct sk_buff *skb,
3816                                      const struct nft_set *set)
3817 {
3818         struct nlattr *concat, *field;
3819         int i;
3820
3821         concat = nla_nest_start_noflag(skb, NFTA_SET_DESC_CONCAT);
3822         if (!concat)
3823                 return -ENOMEM;
3824
3825         for (i = 0; i < set->field_count; i++) {
3826                 field = nla_nest_start_noflag(skb, NFTA_LIST_ELEM);
3827                 if (!field)
3828                         return -ENOMEM;
3829
3830                 if (nla_put_be32(skb, NFTA_SET_FIELD_LEN,
3831                                  htonl(set->field_len[i])))
3832                         return -ENOMEM;
3833
3834                 nla_nest_end(skb, field);
3835         }
3836
3837         nla_nest_end(skb, concat);
3838
3839         return 0;
3840 }
3841
3842 static int nf_tables_fill_set(struct sk_buff *skb, const struct nft_ctx *ctx,
3843                               const struct nft_set *set, u16 event, u16 flags)
3844 {
3845         struct nlmsghdr *nlh;
3846         u32 portid = ctx->portid;
3847         struct nlattr *nest;
3848         u32 seq = ctx->seq;
3849         int i;
3850
3851         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
3852         nlh = nfnl_msg_put(skb, portid, seq, event, flags, ctx->family,
3853                            NFNETLINK_V0, nft_base_seq(ctx->net));
3854         if (!nlh)
3855                 goto nla_put_failure;
3856
3857         if (nla_put_string(skb, NFTA_SET_TABLE, ctx->table->name))
3858                 goto nla_put_failure;
3859         if (nla_put_string(skb, NFTA_SET_NAME, set->name))
3860                 goto nla_put_failure;
3861         if (nla_put_be64(skb, NFTA_SET_HANDLE, cpu_to_be64(set->handle),
3862                          NFTA_SET_PAD))
3863                 goto nla_put_failure;
3864         if (set->flags != 0)
3865                 if (nla_put_be32(skb, NFTA_SET_FLAGS, htonl(set->flags)))
3866                         goto nla_put_failure;
3867
3868         if (nla_put_be32(skb, NFTA_SET_KEY_TYPE, htonl(set->ktype)))
3869                 goto nla_put_failure;
3870         if (nla_put_be32(skb, NFTA_SET_KEY_LEN, htonl(set->klen)))
3871                 goto nla_put_failure;
3872         if (set->flags & NFT_SET_MAP) {
3873                 if (nla_put_be32(skb, NFTA_SET_DATA_TYPE, htonl(set->dtype)))
3874                         goto nla_put_failure;
3875                 if (nla_put_be32(skb, NFTA_SET_DATA_LEN, htonl(set->dlen)))
3876                         goto nla_put_failure;
3877         }
3878         if (set->flags & NFT_SET_OBJECT &&
3879             nla_put_be32(skb, NFTA_SET_OBJ_TYPE, htonl(set->objtype)))
3880                 goto nla_put_failure;
3881
3882         if (set->timeout &&
3883             nla_put_be64(skb, NFTA_SET_TIMEOUT,
3884                          nf_jiffies64_to_msecs(set->timeout),
3885                          NFTA_SET_PAD))
3886                 goto nla_put_failure;
3887         if (set->gc_int &&
3888             nla_put_be32(skb, NFTA_SET_GC_INTERVAL, htonl(set->gc_int)))
3889                 goto nla_put_failure;
3890
3891         if (set->policy != NFT_SET_POL_PERFORMANCE) {
3892                 if (nla_put_be32(skb, NFTA_SET_POLICY, htonl(set->policy)))
3893                         goto nla_put_failure;
3894         }
3895
3896         if (set->udata &&
3897             nla_put(skb, NFTA_SET_USERDATA, set->udlen, set->udata))
3898                 goto nla_put_failure;
3899
3900         nest = nla_nest_start_noflag(skb, NFTA_SET_DESC);
3901         if (!nest)
3902                 goto nla_put_failure;
3903         if (set->size &&
3904             nla_put_be32(skb, NFTA_SET_DESC_SIZE, htonl(set->size)))
3905                 goto nla_put_failure;
3906
3907         if (set->field_count > 1 &&
3908             nf_tables_fill_set_concat(skb, set))
3909                 goto nla_put_failure;
3910
3911         nla_nest_end(skb, nest);
3912
3913         if (set->num_exprs == 1) {
3914                 nest = nla_nest_start_noflag(skb, NFTA_SET_EXPR);
3915                 if (nf_tables_fill_expr_info(skb, set->exprs[0]) < 0)
3916                         goto nla_put_failure;
3917
3918                 nla_nest_end(skb, nest);
3919         } else if (set->num_exprs > 1) {
3920                 nest = nla_nest_start_noflag(skb, NFTA_SET_EXPRESSIONS);
3921                 if (nest == NULL)
3922                         goto nla_put_failure;
3923
3924                 for (i = 0; i < set->num_exprs; i++) {
3925                         if (nft_expr_dump(skb, NFTA_LIST_ELEM,
3926                                           set->exprs[i]) < 0)
3927                                 goto nla_put_failure;
3928                 }
3929                 nla_nest_end(skb, nest);
3930         }
3931
3932         nlmsg_end(skb, nlh);
3933         return 0;
3934
3935 nla_put_failure:
3936         nlmsg_trim(skb, nlh);
3937         return -1;
3938 }
3939
3940 static void nf_tables_set_notify(const struct nft_ctx *ctx,
3941                                  const struct nft_set *set, int event,
3942                                  gfp_t gfp_flags)
3943 {
3944         struct nftables_pernet *nft_net = nft_pernet(ctx->net);
3945         struct sk_buff *skb;
3946         u32 portid = ctx->portid;
3947         int err;
3948
3949         if (!ctx->report &&
3950             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
3951                 return;
3952
3953         skb = nlmsg_new(NLMSG_GOODSIZE, gfp_flags);
3954         if (skb == NULL)
3955                 goto err;
3956
3957         err = nf_tables_fill_set(skb, ctx, set, event, 0);
3958         if (err < 0) {
3959                 kfree_skb(skb);
3960                 goto err;
3961         }
3962
3963         nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);
3964         return;
3965 err:
3966         nfnetlink_set_err(ctx->net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
3967 }
3968
3969 static int nf_tables_dump_sets(struct sk_buff *skb, struct netlink_callback *cb)
3970 {
3971         const struct nft_set *set;
3972         unsigned int idx, s_idx = cb->args[0];
3973         struct nft_table *table, *cur_table = (struct nft_table *)cb->args[2];
3974         struct net *net = sock_net(skb->sk);
3975         struct nft_ctx *ctx = cb->data, ctx_set;
3976         struct nftables_pernet *nft_net;
3977
3978         if (cb->args[1])
3979                 return skb->len;
3980
3981         rcu_read_lock();
3982         nft_net = nft_pernet(net);
3983         cb->seq = nft_net->base_seq;
3984
3985         list_for_each_entry_rcu(table, &nft_net->tables, list) {
3986                 if (ctx->family != NFPROTO_UNSPEC &&
3987                     ctx->family != table->family)
3988                         continue;
3989
3990                 if (ctx->table && ctx->table != table)
3991                         continue;
3992
3993                 if (cur_table) {
3994                         if (cur_table != table)
3995                                 continue;
3996
3997                         cur_table = NULL;
3998                 }
3999                 idx = 0;
4000                 list_for_each_entry_rcu(set, &table->sets, list) {
4001                         if (idx < s_idx)
4002                                 goto cont;
4003                         if (!nft_is_active(net, set))
4004                                 goto cont;
4005
4006                         ctx_set = *ctx;
4007                         ctx_set.table = table;
4008                         ctx_set.family = table->family;
4009
4010                         if (nf_tables_fill_set(skb, &ctx_set, set,
4011                                                NFT_MSG_NEWSET,
4012                                                NLM_F_MULTI) < 0) {
4013                                 cb->args[0] = idx;
4014                                 cb->args[2] = (unsigned long) table;
4015                                 goto done;
4016                         }
4017                         nl_dump_check_consistent(cb, nlmsg_hdr(skb));
4018 cont:
4019                         idx++;
4020                 }
4021                 if (s_idx)
4022                         s_idx = 0;
4023         }
4024         cb->args[1] = 1;
4025 done:
4026         rcu_read_unlock();
4027         return skb->len;
4028 }
4029
4030 static int nf_tables_dump_sets_start(struct netlink_callback *cb)
4031 {
4032         struct nft_ctx *ctx_dump = NULL;
4033
4034         ctx_dump = kmemdup(cb->data, sizeof(*ctx_dump), GFP_ATOMIC);
4035         if (ctx_dump == NULL)
4036                 return -ENOMEM;
4037
4038         cb->data = ctx_dump;
4039         return 0;
4040 }
4041
4042 static int nf_tables_dump_sets_done(struct netlink_callback *cb)
4043 {
4044         kfree(cb->data);
4045         return 0;
4046 }
4047
4048 /* called with rcu_read_lock held */
4049 static int nf_tables_getset(struct sk_buff *skb, const struct nfnl_info *info,
4050                             const struct nlattr * const nla[])
4051 {
4052         struct netlink_ext_ack *extack = info->extack;
4053         u8 genmask = nft_genmask_cur(info->net);
4054         u8 family = info->nfmsg->nfgen_family;
4055         struct nft_table *table = NULL;
4056         struct net *net = info->net;
4057         const struct nft_set *set;
4058         struct sk_buff *skb2;
4059         struct nft_ctx ctx;
4060         int err;
4061
4062         if (nla[NFTA_SET_TABLE]) {
4063                 table = nft_table_lookup(net, nla[NFTA_SET_TABLE], family,
4064                                          genmask, 0);
4065                 if (IS_ERR(table)) {
4066                         NL_SET_BAD_ATTR(extack, nla[NFTA_SET_TABLE]);
4067                         return PTR_ERR(table);
4068                 }
4069         }
4070
4071         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
4072
4073         if (info->nlh->nlmsg_flags & NLM_F_DUMP) {
4074                 struct netlink_dump_control c = {
4075                         .start = nf_tables_dump_sets_start,
4076                         .dump = nf_tables_dump_sets,
4077                         .done = nf_tables_dump_sets_done,
4078                         .data = &ctx,
4079                         .module = THIS_MODULE,
4080                 };
4081
4082                 return nft_netlink_dump_start_rcu(info->sk, skb, info->nlh, &c);
4083         }
4084
4085         /* Only accept unspec with dump */
4086         if (info->nfmsg->nfgen_family == NFPROTO_UNSPEC)
4087                 return -EAFNOSUPPORT;
4088         if (!nla[NFTA_SET_TABLE])
4089                 return -EINVAL;
4090
4091         set = nft_set_lookup(table, nla[NFTA_SET_NAME], genmask);
4092         if (IS_ERR(set))
4093                 return PTR_ERR(set);
4094
4095         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
4096         if (skb2 == NULL)
4097                 return -ENOMEM;
4098
4099         err = nf_tables_fill_set(skb2, &ctx, set, NFT_MSG_NEWSET, 0);
4100         if (err < 0)
4101                 goto err_fill_set_info;
4102
4103         return nfnetlink_unicast(skb2, net, NETLINK_CB(skb).portid);
4104
4105 err_fill_set_info:
4106         kfree_skb(skb2);
4107         return err;
4108 }
4109
4110 static const struct nla_policy nft_concat_policy[NFTA_SET_FIELD_MAX + 1] = {
4111         [NFTA_SET_FIELD_LEN]    = { .type = NLA_U32 },
4112 };
4113
4114 static int nft_set_desc_concat_parse(const struct nlattr *attr,
4115                                      struct nft_set_desc *desc)
4116 {
4117         struct nlattr *tb[NFTA_SET_FIELD_MAX + 1];
4118         u32 len;
4119         int err;
4120
4121         err = nla_parse_nested_deprecated(tb, NFTA_SET_FIELD_MAX, attr,
4122                                           nft_concat_policy, NULL);
4123         if (err < 0)
4124                 return err;
4125
4126         if (!tb[NFTA_SET_FIELD_LEN])
4127                 return -EINVAL;
4128
4129         len = ntohl(nla_get_be32(tb[NFTA_SET_FIELD_LEN]));
4130
4131         if (len * BITS_PER_BYTE / 32 > NFT_REG32_COUNT)
4132                 return -E2BIG;
4133
4134         desc->field_len[desc->field_count++] = len;
4135
4136         return 0;
4137 }
4138
4139 static int nft_set_desc_concat(struct nft_set_desc *desc,
4140                                const struct nlattr *nla)
4141 {
4142         struct nlattr *attr;
4143         int rem, err;
4144
4145         nla_for_each_nested(attr, nla, rem) {
4146                 if (nla_type(attr) != NFTA_LIST_ELEM)
4147                         return -EINVAL;
4148
4149                 err = nft_set_desc_concat_parse(attr, desc);
4150                 if (err < 0)
4151                         return err;
4152         }
4153
4154         return 0;
4155 }
4156
4157 static int nf_tables_set_desc_parse(struct nft_set_desc *desc,
4158                                     const struct nlattr *nla)
4159 {
4160         struct nlattr *da[NFTA_SET_DESC_MAX + 1];
4161         int err;
4162
4163         err = nla_parse_nested_deprecated(da, NFTA_SET_DESC_MAX, nla,
4164                                           nft_set_desc_policy, NULL);
4165         if (err < 0)
4166                 return err;
4167
4168         if (da[NFTA_SET_DESC_SIZE] != NULL)
4169                 desc->size = ntohl(nla_get_be32(da[NFTA_SET_DESC_SIZE]));
4170         if (da[NFTA_SET_DESC_CONCAT])
4171                 err = nft_set_desc_concat(desc, da[NFTA_SET_DESC_CONCAT]);
4172
4173         return err;
4174 }
4175
4176 static int nf_tables_newset(struct sk_buff *skb, const struct nfnl_info *info,
4177                             const struct nlattr * const nla[])
4178 {
4179         u32 ktype, dtype, flags, policy, gc_int, objtype;
4180         struct netlink_ext_ack *extack = info->extack;
4181         u8 genmask = nft_genmask_next(info->net);
4182         u8 family = info->nfmsg->nfgen_family;
4183         const struct nft_set_ops *ops;
4184         struct nft_expr *expr = NULL;
4185         struct net *net = info->net;
4186         struct nft_set_desc desc;
4187         struct nft_table *table;
4188         unsigned char *udata;
4189         struct nft_set *set;
4190         struct nft_ctx ctx;
4191         size_t alloc_size;
4192         u64 timeout;
4193         char *name;
4194         int err, i;
4195         u16 udlen;
4196         u64 size;
4197
4198         if (nla[NFTA_SET_TABLE] == NULL ||
4199             nla[NFTA_SET_NAME] == NULL ||
4200             nla[NFTA_SET_KEY_LEN] == NULL ||
4201             nla[NFTA_SET_ID] == NULL)
4202                 return -EINVAL;
4203
4204         memset(&desc, 0, sizeof(desc));
4205
4206         ktype = NFT_DATA_VALUE;
4207         if (nla[NFTA_SET_KEY_TYPE] != NULL) {
4208                 ktype = ntohl(nla_get_be32(nla[NFTA_SET_KEY_TYPE]));
4209                 if ((ktype & NFT_DATA_RESERVED_MASK) == NFT_DATA_RESERVED_MASK)
4210                         return -EINVAL;
4211         }
4212
4213         desc.klen = ntohl(nla_get_be32(nla[NFTA_SET_KEY_LEN]));
4214         if (desc.klen == 0 || desc.klen > NFT_DATA_VALUE_MAXLEN)
4215                 return -EINVAL;
4216
4217         flags = 0;
4218         if (nla[NFTA_SET_FLAGS] != NULL) {
4219                 flags = ntohl(nla_get_be32(nla[NFTA_SET_FLAGS]));
4220                 if (flags & ~(NFT_SET_ANONYMOUS | NFT_SET_CONSTANT |
4221                               NFT_SET_INTERVAL | NFT_SET_TIMEOUT |
4222                               NFT_SET_MAP | NFT_SET_EVAL |
4223                               NFT_SET_OBJECT | NFT_SET_CONCAT | NFT_SET_EXPR))
4224                         return -EOPNOTSUPP;
4225                 /* Only one of these operations is supported */
4226                 if ((flags & (NFT_SET_MAP | NFT_SET_OBJECT)) ==
4227                              (NFT_SET_MAP | NFT_SET_OBJECT))
4228                         return -EOPNOTSUPP;
4229                 if ((flags & (NFT_SET_EVAL | NFT_SET_OBJECT)) ==
4230                              (NFT_SET_EVAL | NFT_SET_OBJECT))
4231                         return -EOPNOTSUPP;
4232         }
4233
4234         dtype = 0;
4235         if (nla[NFTA_SET_DATA_TYPE] != NULL) {
4236                 if (!(flags & NFT_SET_MAP))
4237                         return -EINVAL;
4238
4239                 dtype = ntohl(nla_get_be32(nla[NFTA_SET_DATA_TYPE]));
4240                 if ((dtype & NFT_DATA_RESERVED_MASK) == NFT_DATA_RESERVED_MASK &&
4241                     dtype != NFT_DATA_VERDICT)
4242                         return -EINVAL;
4243
4244                 if (dtype != NFT_DATA_VERDICT) {
4245                         if (nla[NFTA_SET_DATA_LEN] == NULL)
4246                                 return -EINVAL;
4247                         desc.dlen = ntohl(nla_get_be32(nla[NFTA_SET_DATA_LEN]));
4248                         if (desc.dlen == 0 || desc.dlen > NFT_DATA_VALUE_MAXLEN)
4249                                 return -EINVAL;
4250                 } else
4251                         desc.dlen = sizeof(struct nft_verdict);
4252         } else if (flags & NFT_SET_MAP)
4253                 return -EINVAL;
4254
4255         if (nla[NFTA_SET_OBJ_TYPE] != NULL) {
4256                 if (!(flags & NFT_SET_OBJECT))
4257                         return -EINVAL;
4258
4259                 objtype = ntohl(nla_get_be32(nla[NFTA_SET_OBJ_TYPE]));
4260                 if (objtype == NFT_OBJECT_UNSPEC ||
4261                     objtype > NFT_OBJECT_MAX)
4262                         return -EOPNOTSUPP;
4263         } else if (flags & NFT_SET_OBJECT)
4264                 return -EINVAL;
4265         else
4266                 objtype = NFT_OBJECT_UNSPEC;
4267
4268         timeout = 0;
4269         if (nla[NFTA_SET_TIMEOUT] != NULL) {
4270                 if (!(flags & NFT_SET_TIMEOUT))
4271                         return -EINVAL;
4272
4273                 err = nf_msecs_to_jiffies64(nla[NFTA_SET_TIMEOUT], &timeout);
4274                 if (err)
4275                         return err;
4276         }
4277         gc_int = 0;
4278         if (nla[NFTA_SET_GC_INTERVAL] != NULL) {
4279                 if (!(flags & NFT_SET_TIMEOUT))
4280                         return -EINVAL;
4281                 gc_int = ntohl(nla_get_be32(nla[NFTA_SET_GC_INTERVAL]));
4282         }
4283
4284         policy = NFT_SET_POL_PERFORMANCE;
4285         if (nla[NFTA_SET_POLICY] != NULL)
4286                 policy = ntohl(nla_get_be32(nla[NFTA_SET_POLICY]));
4287
4288         if (nla[NFTA_SET_DESC] != NULL) {
4289                 err = nf_tables_set_desc_parse(&desc, nla[NFTA_SET_DESC]);
4290                 if (err < 0)
4291                         return err;
4292         }
4293
4294         if (nla[NFTA_SET_EXPR] || nla[NFTA_SET_EXPRESSIONS])
4295                 desc.expr = true;
4296
4297         table = nft_table_lookup(net, nla[NFTA_SET_TABLE], family, genmask,
4298                                  NETLINK_CB(skb).portid);
4299         if (IS_ERR(table)) {
4300                 NL_SET_BAD_ATTR(extack, nla[NFTA_SET_TABLE]);
4301                 return PTR_ERR(table);
4302         }
4303
4304         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
4305
4306         set = nft_set_lookup(table, nla[NFTA_SET_NAME], genmask);
4307         if (IS_ERR(set)) {
4308                 if (PTR_ERR(set) != -ENOENT) {
4309                         NL_SET_BAD_ATTR(extack, nla[NFTA_SET_NAME]);
4310                         return PTR_ERR(set);
4311                 }
4312         } else {
4313                 if (info->nlh->nlmsg_flags & NLM_F_EXCL) {
4314                         NL_SET_BAD_ATTR(extack, nla[NFTA_SET_NAME]);
4315                         return -EEXIST;
4316                 }
4317                 if (info->nlh->nlmsg_flags & NLM_F_REPLACE)
4318                         return -EOPNOTSUPP;
4319
4320                 return 0;
4321         }
4322
4323         if (!(info->nlh->nlmsg_flags & NLM_F_CREATE))
4324                 return -ENOENT;
4325
4326         ops = nft_select_set_ops(&ctx, nla, &desc, policy);
4327         if (IS_ERR(ops))
4328                 return PTR_ERR(ops);
4329
4330         udlen = 0;
4331         if (nla[NFTA_SET_USERDATA])
4332                 udlen = nla_len(nla[NFTA_SET_USERDATA]);
4333
4334         size = 0;
4335         if (ops->privsize != NULL)
4336                 size = ops->privsize(nla, &desc);
4337         alloc_size = sizeof(*set) + size + udlen;
4338         if (alloc_size < size)
4339                 return -ENOMEM;
4340         set = kvzalloc(alloc_size, GFP_KERNEL);
4341         if (!set)
4342                 return -ENOMEM;
4343
4344         name = nla_strdup(nla[NFTA_SET_NAME], GFP_KERNEL);
4345         if (!name) {
4346                 err = -ENOMEM;
4347                 goto err_set_name;
4348         }
4349
4350         err = nf_tables_set_alloc_name(&ctx, set, name);
4351         kfree(name);
4352         if (err < 0)
4353                 goto err_set_name;
4354
4355         udata = NULL;
4356         if (udlen) {
4357                 udata = set->data + size;
4358                 nla_memcpy(udata, nla[NFTA_SET_USERDATA], udlen);
4359         }
4360
4361         INIT_LIST_HEAD(&set->bindings);
4362         INIT_LIST_HEAD(&set->catchall_list);
4363         set->table = table;
4364         write_pnet(&set->net, net);
4365         set->ops = ops;
4366         set->ktype = ktype;
4367         set->klen = desc.klen;
4368         set->dtype = dtype;
4369         set->objtype = objtype;
4370         set->dlen = desc.dlen;
4371         set->flags = flags;
4372         set->size = desc.size;
4373         set->policy = policy;
4374         set->udlen = udlen;
4375         set->udata = udata;
4376         set->timeout = timeout;
4377         set->gc_int = gc_int;
4378
4379         set->field_count = desc.field_count;
4380         for (i = 0; i < desc.field_count; i++)
4381                 set->field_len[i] = desc.field_len[i];
4382
4383         err = ops->init(set, &desc, nla);
4384         if (err < 0)
4385                 goto err_set_init;
4386
4387         if (nla[NFTA_SET_EXPR]) {
4388                 expr = nft_set_elem_expr_alloc(&ctx, set, nla[NFTA_SET_EXPR]);
4389                 if (IS_ERR(expr)) {
4390                         err = PTR_ERR(expr);
4391                         goto err_set_expr_alloc;
4392                 }
4393                 set->exprs[0] = expr;
4394                 set->num_exprs++;
4395         } else if (nla[NFTA_SET_EXPRESSIONS]) {
4396                 struct nft_expr *expr;
4397                 struct nlattr *tmp;
4398                 int left;
4399
4400                 if (!(flags & NFT_SET_EXPR)) {
4401                         err = -EINVAL;
4402                         goto err_set_expr_alloc;
4403                 }
4404                 i = 0;
4405                 nla_for_each_nested(tmp, nla[NFTA_SET_EXPRESSIONS], left) {
4406                         if (i == NFT_SET_EXPR_MAX) {
4407                                 err = -E2BIG;
4408                                 goto err_set_expr_alloc;
4409                         }
4410                         if (nla_type(tmp) != NFTA_LIST_ELEM) {
4411                                 err = -EINVAL;
4412                                 goto err_set_expr_alloc;
4413                         }
4414                         expr = nft_set_elem_expr_alloc(&ctx, set, tmp);
4415                         if (IS_ERR(expr)) {
4416                                 err = PTR_ERR(expr);
4417                                 goto err_set_expr_alloc;
4418                         }
4419                         set->exprs[i++] = expr;
4420                         set->num_exprs++;
4421                 }
4422         }
4423
4424         set->handle = nf_tables_alloc_handle(table);
4425
4426         err = nft_trans_set_add(&ctx, NFT_MSG_NEWSET, set);
4427         if (err < 0)
4428                 goto err_set_expr_alloc;
4429
4430         list_add_tail_rcu(&set->list, &table->sets);
4431         table->use++;
4432         return 0;
4433
4434 err_set_expr_alloc:
4435         for (i = 0; i < set->num_exprs; i++)
4436                 nft_expr_destroy(&ctx, set->exprs[i]);
4437
4438         ops->destroy(set);
4439 err_set_init:
4440         kfree(set->name);
4441 err_set_name:
4442         kvfree(set);
4443         return err;
4444 }
4445
4446 struct nft_set_elem_catchall {
4447         struct list_head        list;
4448         struct rcu_head         rcu;
4449         void                    *elem;
4450 };
4451
4452 static void nft_set_catchall_destroy(const struct nft_ctx *ctx,
4453                                      struct nft_set *set)
4454 {
4455         struct nft_set_elem_catchall *catchall;
4456
4457         list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
4458                 list_del_rcu(&catchall->list);
4459                 nft_set_elem_destroy(set, catchall->elem, true);
4460                 kfree_rcu(catchall);
4461         }
4462 }
4463
4464 static void nft_set_destroy(const struct nft_ctx *ctx, struct nft_set *set)
4465 {
4466         int i;
4467
4468         if (WARN_ON(set->use > 0))
4469                 return;
4470
4471         for (i = 0; i < set->num_exprs; i++)
4472                 nft_expr_destroy(ctx, set->exprs[i]);
4473
4474         set->ops->destroy(set);
4475         nft_set_catchall_destroy(ctx, set);
4476         kfree(set->name);
4477         kvfree(set);
4478 }
4479
4480 static int nf_tables_delset(struct sk_buff *skb, const struct nfnl_info *info,
4481                             const struct nlattr * const nla[])
4482 {
4483         struct netlink_ext_ack *extack = info->extack;
4484         u8 genmask = nft_genmask_next(info->net);
4485         u8 family = info->nfmsg->nfgen_family;
4486         struct net *net = info->net;
4487         const struct nlattr *attr;
4488         struct nft_table *table;
4489         struct nft_set *set;
4490         struct nft_ctx ctx;
4491
4492         if (info->nfmsg->nfgen_family == NFPROTO_UNSPEC)
4493                 return -EAFNOSUPPORT;
4494
4495         table = nft_table_lookup(net, nla[NFTA_SET_TABLE], family,
4496                                  genmask, NETLINK_CB(skb).portid);
4497         if (IS_ERR(table)) {
4498                 NL_SET_BAD_ATTR(extack, nla[NFTA_SET_TABLE]);
4499                 return PTR_ERR(table);
4500         }
4501
4502         if (nla[NFTA_SET_HANDLE]) {
4503                 attr = nla[NFTA_SET_HANDLE];
4504                 set = nft_set_lookup_byhandle(table, attr, genmask);
4505         } else {
4506                 attr = nla[NFTA_SET_NAME];
4507                 set = nft_set_lookup(table, attr, genmask);
4508         }
4509
4510         if (IS_ERR(set)) {
4511                 NL_SET_BAD_ATTR(extack, attr);
4512                 return PTR_ERR(set);
4513         }
4514         if (set->use ||
4515             (info->nlh->nlmsg_flags & NLM_F_NONREC &&
4516              atomic_read(&set->nelems) > 0)) {
4517                 NL_SET_BAD_ATTR(extack, attr);
4518                 return -EBUSY;
4519         }
4520
4521         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
4522
4523         return nft_delset(&ctx, set);
4524 }
4525
4526 static int nft_validate_register_store(const struct nft_ctx *ctx,
4527                                        enum nft_registers reg,
4528                                        const struct nft_data *data,
4529                                        enum nft_data_types type,
4530                                        unsigned int len);
4531
4532 static int nft_setelem_data_validate(const struct nft_ctx *ctx,
4533                                      struct nft_set *set,
4534                                      struct nft_set_elem *elem)
4535 {
4536         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
4537         enum nft_registers dreg;
4538
4539         dreg = nft_type_to_reg(set->dtype);
4540         return nft_validate_register_store(ctx, dreg, nft_set_ext_data(ext),
4541                                            set->dtype == NFT_DATA_VERDICT ?
4542                                            NFT_DATA_VERDICT : NFT_DATA_VALUE,
4543                                            set->dlen);
4544 }
4545
4546 static int nf_tables_bind_check_setelem(const struct nft_ctx *ctx,
4547                                         struct nft_set *set,
4548                                         const struct nft_set_iter *iter,
4549                                         struct nft_set_elem *elem)
4550 {
4551         return nft_setelem_data_validate(ctx, set, elem);
4552 }
4553
4554 static int nft_set_catchall_bind_check(const struct nft_ctx *ctx,
4555                                        struct nft_set *set)
4556 {
4557         u8 genmask = nft_genmask_next(ctx->net);
4558         struct nft_set_elem_catchall *catchall;
4559         struct nft_set_elem elem;
4560         struct nft_set_ext *ext;
4561         int ret = 0;
4562
4563         list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
4564                 ext = nft_set_elem_ext(set, catchall->elem);
4565                 if (!nft_set_elem_active(ext, genmask))
4566                         continue;
4567
4568                 elem.priv = catchall->elem;
4569                 ret = nft_setelem_data_validate(ctx, set, &elem);
4570                 if (ret < 0)
4571                         break;
4572         }
4573
4574         return ret;
4575 }
4576
4577 int nf_tables_bind_set(const struct nft_ctx *ctx, struct nft_set *set,
4578                        struct nft_set_binding *binding)
4579 {
4580         struct nft_set_binding *i;
4581         struct nft_set_iter iter;
4582
4583         if (set->use == UINT_MAX)
4584                 return -EOVERFLOW;
4585
4586         if (!list_empty(&set->bindings) && nft_set_is_anonymous(set))
4587                 return -EBUSY;
4588
4589         if (binding->flags & NFT_SET_MAP) {
4590                 /* If the set is already bound to the same chain all
4591                  * jumps are already validated for that chain.
4592                  */
4593                 list_for_each_entry(i, &set->bindings, list) {
4594                         if (i->flags & NFT_SET_MAP &&
4595                             i->chain == binding->chain)
4596                                 goto bind;
4597                 }
4598
4599                 iter.genmask    = nft_genmask_next(ctx->net);
4600                 iter.skip       = 0;
4601                 iter.count      = 0;
4602                 iter.err        = 0;
4603                 iter.fn         = nf_tables_bind_check_setelem;
4604
4605                 set->ops->walk(ctx, set, &iter);
4606                 if (!iter.err)
4607                         iter.err = nft_set_catchall_bind_check(ctx, set);
4608
4609                 if (iter.err < 0)
4610                         return iter.err;
4611         }
4612 bind:
4613         binding->chain = ctx->chain;
4614         list_add_tail_rcu(&binding->list, &set->bindings);
4615         nft_set_trans_bind(ctx, set);
4616         set->use++;
4617
4618         return 0;
4619 }
4620 EXPORT_SYMBOL_GPL(nf_tables_bind_set);
4621
4622 static void nf_tables_unbind_set(const struct nft_ctx *ctx, struct nft_set *set,
4623                                  struct nft_set_binding *binding, bool event)
4624 {
4625         list_del_rcu(&binding->list);
4626
4627         if (list_empty(&set->bindings) && nft_set_is_anonymous(set)) {
4628                 list_del_rcu(&set->list);
4629                 if (event)
4630                         nf_tables_set_notify(ctx, set, NFT_MSG_DELSET,
4631                                              GFP_KERNEL);
4632         }
4633 }
4634
4635 void nf_tables_deactivate_set(const struct nft_ctx *ctx, struct nft_set *set,
4636                               struct nft_set_binding *binding,
4637                               enum nft_trans_phase phase)
4638 {
4639         switch (phase) {
4640         case NFT_TRANS_PREPARE:
4641                 set->use--;
4642                 return;
4643         case NFT_TRANS_ABORT:
4644         case NFT_TRANS_RELEASE:
4645                 set->use--;
4646                 fallthrough;
4647         default:
4648                 nf_tables_unbind_set(ctx, set, binding,
4649                                      phase == NFT_TRANS_COMMIT);
4650         }
4651 }
4652 EXPORT_SYMBOL_GPL(nf_tables_deactivate_set);
4653
4654 void nf_tables_destroy_set(const struct nft_ctx *ctx, struct nft_set *set)
4655 {
4656         if (list_empty(&set->bindings) && nft_set_is_anonymous(set))
4657                 nft_set_destroy(ctx, set);
4658 }
4659 EXPORT_SYMBOL_GPL(nf_tables_destroy_set);
4660
4661 const struct nft_set_ext_type nft_set_ext_types[] = {
4662         [NFT_SET_EXT_KEY]               = {
4663                 .align  = __alignof__(u32),
4664         },
4665         [NFT_SET_EXT_DATA]              = {
4666                 .align  = __alignof__(u32),
4667         },
4668         [NFT_SET_EXT_EXPRESSIONS]       = {
4669                 .align  = __alignof__(struct nft_set_elem_expr),
4670         },
4671         [NFT_SET_EXT_OBJREF]            = {
4672                 .len    = sizeof(struct nft_object *),
4673                 .align  = __alignof__(struct nft_object *),
4674         },
4675         [NFT_SET_EXT_FLAGS]             = {
4676                 .len    = sizeof(u8),
4677                 .align  = __alignof__(u8),
4678         },
4679         [NFT_SET_EXT_TIMEOUT]           = {
4680                 .len    = sizeof(u64),
4681                 .align  = __alignof__(u64),
4682         },
4683         [NFT_SET_EXT_EXPIRATION]        = {
4684                 .len    = sizeof(u64),
4685                 .align  = __alignof__(u64),
4686         },
4687         [NFT_SET_EXT_USERDATA]          = {
4688                 .len    = sizeof(struct nft_userdata),
4689                 .align  = __alignof__(struct nft_userdata),
4690         },
4691         [NFT_SET_EXT_KEY_END]           = {
4692                 .align  = __alignof__(u32),
4693         },
4694 };
4695
4696 /*
4697  * Set elements
4698  */
4699
4700 static const struct nla_policy nft_set_elem_policy[NFTA_SET_ELEM_MAX + 1] = {
4701         [NFTA_SET_ELEM_KEY]             = { .type = NLA_NESTED },
4702         [NFTA_SET_ELEM_DATA]            = { .type = NLA_NESTED },
4703         [NFTA_SET_ELEM_FLAGS]           = { .type = NLA_U32 },
4704         [NFTA_SET_ELEM_TIMEOUT]         = { .type = NLA_U64 },
4705         [NFTA_SET_ELEM_EXPIRATION]      = { .type = NLA_U64 },
4706         [NFTA_SET_ELEM_USERDATA]        = { .type = NLA_BINARY,
4707                                             .len = NFT_USERDATA_MAXLEN },
4708         [NFTA_SET_ELEM_EXPR]            = { .type = NLA_NESTED },
4709         [NFTA_SET_ELEM_OBJREF]          = { .type = NLA_STRING,
4710                                             .len = NFT_OBJ_MAXNAMELEN - 1 },
4711         [NFTA_SET_ELEM_KEY_END]         = { .type = NLA_NESTED },
4712         [NFTA_SET_ELEM_EXPRESSIONS]     = { .type = NLA_NESTED },
4713 };
4714
4715 static const struct nla_policy nft_set_elem_list_policy[NFTA_SET_ELEM_LIST_MAX + 1] = {
4716         [NFTA_SET_ELEM_LIST_TABLE]      = { .type = NLA_STRING,
4717                                             .len = NFT_TABLE_MAXNAMELEN - 1 },
4718         [NFTA_SET_ELEM_LIST_SET]        = { .type = NLA_STRING,
4719                                             .len = NFT_SET_MAXNAMELEN - 1 },
4720         [NFTA_SET_ELEM_LIST_ELEMENTS]   = { .type = NLA_NESTED },
4721         [NFTA_SET_ELEM_LIST_SET_ID]     = { .type = NLA_U32 },
4722 };
4723
4724 static int nft_set_elem_expr_dump(struct sk_buff *skb,
4725                                   const struct nft_set *set,
4726                                   const struct nft_set_ext *ext)
4727 {
4728         struct nft_set_elem_expr *elem_expr;
4729         u32 size, num_exprs = 0;
4730         struct nft_expr *expr;
4731         struct nlattr *nest;
4732
4733         elem_expr = nft_set_ext_expr(ext);
4734         nft_setelem_expr_foreach(expr, elem_expr, size)
4735                 num_exprs++;
4736
4737         if (num_exprs == 1) {
4738                 expr = nft_setelem_expr_at(elem_expr, 0);
4739                 if (nft_expr_dump(skb, NFTA_SET_ELEM_EXPR, expr) < 0)
4740                         return -1;
4741
4742                 return 0;
4743         } else if (num_exprs > 1) {
4744                 nest = nla_nest_start_noflag(skb, NFTA_SET_ELEM_EXPRESSIONS);
4745                 if (nest == NULL)
4746                         goto nla_put_failure;
4747
4748                 nft_setelem_expr_foreach(expr, elem_expr, size) {
4749                         expr = nft_setelem_expr_at(elem_expr, size);
4750                         if (nft_expr_dump(skb, NFTA_LIST_ELEM, expr) < 0)
4751                                 goto nla_put_failure;
4752                 }
4753                 nla_nest_end(skb, nest);
4754         }
4755         return 0;
4756
4757 nla_put_failure:
4758         return -1;
4759 }
4760
4761 static int nf_tables_fill_setelem(struct sk_buff *skb,
4762                                   const struct nft_set *set,
4763                                   const struct nft_set_elem *elem)
4764 {
4765         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
4766         unsigned char *b = skb_tail_pointer(skb);
4767         struct nlattr *nest;
4768
4769         nest = nla_nest_start_noflag(skb, NFTA_LIST_ELEM);
4770         if (nest == NULL)
4771                 goto nla_put_failure;
4772
4773         if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY) &&
4774             nft_data_dump(skb, NFTA_SET_ELEM_KEY, nft_set_ext_key(ext),
4775                           NFT_DATA_VALUE, set->klen) < 0)
4776                 goto nla_put_failure;
4777
4778         if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY_END) &&
4779             nft_data_dump(skb, NFTA_SET_ELEM_KEY_END, nft_set_ext_key_end(ext),
4780                           NFT_DATA_VALUE, set->klen) < 0)
4781                 goto nla_put_failure;
4782
4783         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA) &&
4784             nft_data_dump(skb, NFTA_SET_ELEM_DATA, nft_set_ext_data(ext),
4785                           set->dtype == NFT_DATA_VERDICT ? NFT_DATA_VERDICT : NFT_DATA_VALUE,
4786                           set->dlen) < 0)
4787                 goto nla_put_failure;
4788
4789         if (nft_set_ext_exists(ext, NFT_SET_EXT_EXPRESSIONS) &&
4790             nft_set_elem_expr_dump(skb, set, ext))
4791                 goto nla_put_failure;
4792
4793         if (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF) &&
4794             nla_put_string(skb, NFTA_SET_ELEM_OBJREF,
4795                            (*nft_set_ext_obj(ext))->key.name) < 0)
4796                 goto nla_put_failure;
4797
4798         if (nft_set_ext_exists(ext, NFT_SET_EXT_FLAGS) &&
4799             nla_put_be32(skb, NFTA_SET_ELEM_FLAGS,
4800                          htonl(*nft_set_ext_flags(ext))))
4801                 goto nla_put_failure;
4802
4803         if (nft_set_ext_exists(ext, NFT_SET_EXT_TIMEOUT) &&
4804             nla_put_be64(skb, NFTA_SET_ELEM_TIMEOUT,
4805                          nf_jiffies64_to_msecs(*nft_set_ext_timeout(ext)),
4806                          NFTA_SET_ELEM_PAD))
4807                 goto nla_put_failure;
4808
4809         if (nft_set_ext_exists(ext, NFT_SET_EXT_EXPIRATION)) {
4810                 u64 expires, now = get_jiffies_64();
4811
4812                 expires = *nft_set_ext_expiration(ext);
4813                 if (time_before64(now, expires))
4814                         expires -= now;
4815                 else
4816                         expires = 0;
4817
4818                 if (nla_put_be64(skb, NFTA_SET_ELEM_EXPIRATION,
4819                                  nf_jiffies64_to_msecs(expires),
4820                                  NFTA_SET_ELEM_PAD))
4821                         goto nla_put_failure;
4822         }
4823
4824         if (nft_set_ext_exists(ext, NFT_SET_EXT_USERDATA)) {
4825                 struct nft_userdata *udata;
4826
4827                 udata = nft_set_ext_userdata(ext);
4828                 if (nla_put(skb, NFTA_SET_ELEM_USERDATA,
4829                             udata->len + 1, udata->data))
4830                         goto nla_put_failure;
4831         }
4832
4833         nla_nest_end(skb, nest);
4834         return 0;
4835
4836 nla_put_failure:
4837         nlmsg_trim(skb, b);
4838         return -EMSGSIZE;
4839 }
4840
4841 struct nft_set_dump_args {
4842         const struct netlink_callback   *cb;
4843         struct nft_set_iter             iter;
4844         struct sk_buff                  *skb;
4845 };
4846
4847 static int nf_tables_dump_setelem(const struct nft_ctx *ctx,
4848                                   struct nft_set *set,
4849                                   const struct nft_set_iter *iter,
4850                                   struct nft_set_elem *elem)
4851 {
4852         struct nft_set_dump_args *args;
4853
4854         args = container_of(iter, struct nft_set_dump_args, iter);
4855         return nf_tables_fill_setelem(args->skb, set, elem);
4856 }
4857
4858 struct nft_set_dump_ctx {
4859         const struct nft_set    *set;
4860         struct nft_ctx          ctx;
4861 };
4862
4863 static int nft_set_catchall_dump(struct net *net, struct sk_buff *skb,
4864                                  const struct nft_set *set)
4865 {
4866         struct nft_set_elem_catchall *catchall;
4867         u8 genmask = nft_genmask_cur(net);
4868         struct nft_set_elem elem;
4869         struct nft_set_ext *ext;
4870         int ret = 0;
4871
4872         list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
4873                 ext = nft_set_elem_ext(set, catchall->elem);
4874                 if (!nft_set_elem_active(ext, genmask) ||
4875                     nft_set_elem_expired(ext))
4876                         continue;
4877
4878                 elem.priv = catchall->elem;
4879                 ret = nf_tables_fill_setelem(skb, set, &elem);
4880                 break;
4881         }
4882
4883         return ret;
4884 }
4885
4886 static int nf_tables_dump_set(struct sk_buff *skb, struct netlink_callback *cb)
4887 {
4888         struct nft_set_dump_ctx *dump_ctx = cb->data;
4889         struct net *net = sock_net(skb->sk);
4890         struct nftables_pernet *nft_net;
4891         struct nft_table *table;
4892         struct nft_set *set;
4893         struct nft_set_dump_args args;
4894         bool set_found = false;
4895         struct nlmsghdr *nlh;
4896         struct nlattr *nest;
4897         u32 portid, seq;
4898         int event;
4899
4900         rcu_read_lock();
4901         nft_net = nft_pernet(net);
4902         list_for_each_entry_rcu(table, &nft_net->tables, list) {
4903                 if (dump_ctx->ctx.family != NFPROTO_UNSPEC &&
4904                     dump_ctx->ctx.family != table->family)
4905                         continue;
4906
4907                 if (table != dump_ctx->ctx.table)
4908                         continue;
4909
4910                 list_for_each_entry_rcu(set, &table->sets, list) {
4911                         if (set == dump_ctx->set) {
4912                                 set_found = true;
4913                                 break;
4914                         }
4915                 }
4916                 break;
4917         }
4918
4919         if (!set_found) {
4920                 rcu_read_unlock();
4921                 return -ENOENT;
4922         }
4923
4924         event  = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWSETELEM);
4925         portid = NETLINK_CB(cb->skb).portid;
4926         seq    = cb->nlh->nlmsg_seq;
4927
4928         nlh = nfnl_msg_put(skb, portid, seq, event, NLM_F_MULTI,
4929                            table->family, NFNETLINK_V0, nft_base_seq(net));
4930         if (!nlh)
4931                 goto nla_put_failure;
4932
4933         if (nla_put_string(skb, NFTA_SET_ELEM_LIST_TABLE, table->name))
4934                 goto nla_put_failure;
4935         if (nla_put_string(skb, NFTA_SET_ELEM_LIST_SET, set->name))
4936                 goto nla_put_failure;
4937
4938         nest = nla_nest_start_noflag(skb, NFTA_SET_ELEM_LIST_ELEMENTS);
4939         if (nest == NULL)
4940                 goto nla_put_failure;
4941
4942         args.cb                 = cb;
4943         args.skb                = skb;
4944         args.iter.genmask       = nft_genmask_cur(net);
4945         args.iter.skip          = cb->args[0];
4946         args.iter.count         = 0;
4947         args.iter.err           = 0;
4948         args.iter.fn            = nf_tables_dump_setelem;
4949         set->ops->walk(&dump_ctx->ctx, set, &args.iter);
4950
4951         if (!args.iter.err && args.iter.count == cb->args[0])
4952                 args.iter.err = nft_set_catchall_dump(net, skb, set);
4953         rcu_read_unlock();
4954
4955         nla_nest_end(skb, nest);
4956         nlmsg_end(skb, nlh);
4957
4958         if (args.iter.err && args.iter.err != -EMSGSIZE)
4959                 return args.iter.err;
4960         if (args.iter.count == cb->args[0])
4961                 return 0;
4962
4963         cb->args[0] = args.iter.count;
4964         return skb->len;
4965
4966 nla_put_failure:
4967         rcu_read_unlock();
4968         return -ENOSPC;
4969 }
4970
4971 static int nf_tables_dump_set_start(struct netlink_callback *cb)
4972 {
4973         struct nft_set_dump_ctx *dump_ctx = cb->data;
4974
4975         cb->data = kmemdup(dump_ctx, sizeof(*dump_ctx), GFP_ATOMIC);
4976
4977         return cb->data ? 0 : -ENOMEM;
4978 }
4979
4980 static int nf_tables_dump_set_done(struct netlink_callback *cb)
4981 {
4982         kfree(cb->data);
4983         return 0;
4984 }
4985
4986 static int nf_tables_fill_setelem_info(struct sk_buff *skb,
4987                                        const struct nft_ctx *ctx, u32 seq,
4988                                        u32 portid, int event, u16 flags,
4989                                        const struct nft_set *set,
4990                                        const struct nft_set_elem *elem)
4991 {
4992         struct nlmsghdr *nlh;
4993         struct nlattr *nest;
4994         int err;
4995
4996         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
4997         nlh = nfnl_msg_put(skb, portid, seq, event, flags, ctx->family,
4998                            NFNETLINK_V0, nft_base_seq(ctx->net));
4999         if (!nlh)
5000                 goto nla_put_failure;
5001
5002         if (nla_put_string(skb, NFTA_SET_TABLE, ctx->table->name))
5003                 goto nla_put_failure;
5004         if (nla_put_string(skb, NFTA_SET_NAME, set->name))
5005                 goto nla_put_failure;
5006
5007         nest = nla_nest_start_noflag(skb, NFTA_SET_ELEM_LIST_ELEMENTS);
5008         if (nest == NULL)
5009                 goto nla_put_failure;
5010
5011         err = nf_tables_fill_setelem(skb, set, elem);
5012         if (err < 0)
5013                 goto nla_put_failure;
5014
5015         nla_nest_end(skb, nest);
5016
5017         nlmsg_end(skb, nlh);
5018         return 0;
5019
5020 nla_put_failure:
5021         nlmsg_trim(skb, nlh);
5022         return -1;
5023 }
5024
5025 static int nft_setelem_parse_flags(const struct nft_set *set,
5026                                    const struct nlattr *attr, u32 *flags)
5027 {
5028         if (attr == NULL)
5029                 return 0;
5030
5031         *flags = ntohl(nla_get_be32(attr));
5032         if (*flags & ~(NFT_SET_ELEM_INTERVAL_END | NFT_SET_ELEM_CATCHALL))
5033                 return -EOPNOTSUPP;
5034         if (!(set->flags & NFT_SET_INTERVAL) &&
5035             *flags & NFT_SET_ELEM_INTERVAL_END)
5036                 return -EINVAL;
5037
5038         return 0;
5039 }
5040
5041 static int nft_setelem_parse_key(struct nft_ctx *ctx, struct nft_set *set,
5042                                  struct nft_data *key, struct nlattr *attr)
5043 {
5044         struct nft_data_desc desc;
5045         int err;
5046
5047         err = nft_data_init(ctx, key, NFT_DATA_VALUE_MAXLEN, &desc, attr);
5048         if (err < 0)
5049                 return err;
5050
5051         if (desc.type != NFT_DATA_VALUE || desc.len != set->klen) {
5052                 nft_data_release(key, desc.type);
5053                 return -EINVAL;
5054         }
5055
5056         return 0;
5057 }
5058
5059 static int nft_setelem_parse_data(struct nft_ctx *ctx, struct nft_set *set,
5060                                   struct nft_data_desc *desc,
5061                                   struct nft_data *data,
5062                                   struct nlattr *attr)
5063 {
5064         int err;
5065
5066         err = nft_data_init(ctx, data, NFT_DATA_VALUE_MAXLEN, desc, attr);
5067         if (err < 0)
5068                 return err;
5069
5070         if (desc->type != NFT_DATA_VERDICT && desc->len != set->dlen) {
5071                 nft_data_release(data, desc->type);
5072                 return -EINVAL;
5073         }
5074
5075         return 0;
5076 }
5077
5078 static void *nft_setelem_catchall_get(const struct net *net,
5079                                       const struct nft_set *set)
5080 {
5081         struct nft_set_elem_catchall *catchall;
5082         u8 genmask = nft_genmask_cur(net);
5083         struct nft_set_ext *ext;
5084         void *priv = NULL;
5085
5086         list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
5087                 ext = nft_set_elem_ext(set, catchall->elem);
5088                 if (!nft_set_elem_active(ext, genmask) ||
5089                     nft_set_elem_expired(ext))
5090                         continue;
5091
5092                 priv = catchall->elem;
5093                 break;
5094         }
5095
5096         return priv;
5097 }
5098
5099 static int nft_setelem_get(struct nft_ctx *ctx, struct nft_set *set,
5100                            struct nft_set_elem *elem, u32 flags)
5101 {
5102         void *priv;
5103
5104         if (!(flags & NFT_SET_ELEM_CATCHALL)) {
5105                 priv = set->ops->get(ctx->net, set, elem, flags);
5106                 if (IS_ERR(priv))
5107                         return PTR_ERR(priv);
5108         } else {
5109                 priv = nft_setelem_catchall_get(ctx->net, set);
5110                 if (!priv)
5111                         return -ENOENT;
5112         }
5113         elem->priv = priv;
5114
5115         return 0;
5116 }
5117
5118 static int nft_get_set_elem(struct nft_ctx *ctx, struct nft_set *set,
5119                             const struct nlattr *attr)
5120 {
5121         struct nlattr *nla[NFTA_SET_ELEM_MAX + 1];
5122         struct nft_set_elem elem;
5123         struct sk_buff *skb;
5124         uint32_t flags = 0;
5125         int err;
5126
5127         err = nla_parse_nested_deprecated(nla, NFTA_SET_ELEM_MAX, attr,
5128                                           nft_set_elem_policy, NULL);
5129         if (err < 0)
5130                 return err;
5131
5132         err = nft_setelem_parse_flags(set, nla[NFTA_SET_ELEM_FLAGS], &flags);
5133         if (err < 0)
5134                 return err;
5135
5136         if (!nla[NFTA_SET_ELEM_KEY] && !(flags & NFT_SET_ELEM_CATCHALL))
5137                 return -EINVAL;
5138
5139         if (nla[NFTA_SET_ELEM_KEY]) {
5140                 err = nft_setelem_parse_key(ctx, set, &elem.key.val,
5141                                             nla[NFTA_SET_ELEM_KEY]);
5142                 if (err < 0)
5143                         return err;
5144         }
5145
5146         if (nla[NFTA_SET_ELEM_KEY_END]) {
5147                 err = nft_setelem_parse_key(ctx, set, &elem.key_end.val,
5148                                             nla[NFTA_SET_ELEM_KEY_END]);
5149                 if (err < 0)
5150                         return err;
5151         }
5152
5153         err = nft_setelem_get(ctx, set, &elem, flags);
5154         if (err < 0)
5155                 return err;
5156
5157         err = -ENOMEM;
5158         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_ATOMIC);
5159         if (skb == NULL)
5160                 return err;
5161
5162         err = nf_tables_fill_setelem_info(skb, ctx, ctx->seq, ctx->portid,
5163                                           NFT_MSG_NEWSETELEM, 0, set, &elem);
5164         if (err < 0)
5165                 goto err_fill_setelem;
5166
5167         return nfnetlink_unicast(skb, ctx->net, ctx->portid);
5168
5169 err_fill_setelem:
5170         kfree_skb(skb);
5171         return err;
5172 }
5173
5174 /* called with rcu_read_lock held */
5175 static int nf_tables_getsetelem(struct sk_buff *skb,
5176                                 const struct nfnl_info *info,
5177                                 const struct nlattr * const nla[])
5178 {
5179         struct netlink_ext_ack *extack = info->extack;
5180         u8 genmask = nft_genmask_cur(info->net);
5181         u8 family = info->nfmsg->nfgen_family;
5182         struct net *net = info->net;
5183         struct nft_table *table;
5184         struct nft_set *set;
5185         struct nlattr *attr;
5186         struct nft_ctx ctx;
5187         int rem, err = 0;
5188
5189         table = nft_table_lookup(net, nla[NFTA_SET_ELEM_LIST_TABLE], family,
5190                                  genmask, NETLINK_CB(skb).portid);
5191         if (IS_ERR(table)) {
5192                 NL_SET_BAD_ATTR(extack, nla[NFTA_SET_ELEM_LIST_TABLE]);
5193                 return PTR_ERR(table);
5194         }
5195
5196         set = nft_set_lookup(table, nla[NFTA_SET_ELEM_LIST_SET], genmask);
5197         if (IS_ERR(set))
5198                 return PTR_ERR(set);
5199
5200         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
5201
5202         if (info->nlh->nlmsg_flags & NLM_F_DUMP) {
5203                 struct netlink_dump_control c = {
5204                         .start = nf_tables_dump_set_start,
5205                         .dump = nf_tables_dump_set,
5206                         .done = nf_tables_dump_set_done,
5207                         .module = THIS_MODULE,
5208                 };
5209                 struct nft_set_dump_ctx dump_ctx = {
5210                         .set = set,
5211                         .ctx = ctx,
5212                 };
5213
5214                 c.data = &dump_ctx;
5215                 return nft_netlink_dump_start_rcu(info->sk, skb, info->nlh, &c);
5216         }
5217
5218         if (!nla[NFTA_SET_ELEM_LIST_ELEMENTS])
5219                 return -EINVAL;
5220
5221         nla_for_each_nested(attr, nla[NFTA_SET_ELEM_LIST_ELEMENTS], rem) {
5222                 err = nft_get_set_elem(&ctx, set, attr);
5223                 if (err < 0)
5224                         break;
5225         }
5226
5227         return err;
5228 }
5229
5230 static void nf_tables_setelem_notify(const struct nft_ctx *ctx,
5231                                      const struct nft_set *set,
5232                                      const struct nft_set_elem *elem,
5233                                      int event, u16 flags)
5234 {
5235         struct nftables_pernet *nft_net;
5236         struct net *net = ctx->net;
5237         u32 portid = ctx->portid;
5238         struct sk_buff *skb;
5239         int err;
5240
5241         if (!ctx->report && !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
5242                 return;
5243
5244         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
5245         if (skb == NULL)
5246                 goto err;
5247
5248         err = nf_tables_fill_setelem_info(skb, ctx, 0, portid, event, flags,
5249                                           set, elem);
5250         if (err < 0) {
5251                 kfree_skb(skb);
5252                 goto err;
5253         }
5254
5255         nft_net = nft_pernet(net);
5256         nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);
5257         return;
5258 err:
5259         nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
5260 }
5261
5262 static struct nft_trans *nft_trans_elem_alloc(struct nft_ctx *ctx,
5263                                               int msg_type,
5264                                               struct nft_set *set)
5265 {
5266         struct nft_trans *trans;
5267
5268         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_elem));
5269         if (trans == NULL)
5270                 return NULL;
5271
5272         nft_trans_elem_set(trans) = set;
5273         return trans;
5274 }
5275
5276 struct nft_expr *nft_set_elem_expr_alloc(const struct nft_ctx *ctx,
5277                                          const struct nft_set *set,
5278                                          const struct nlattr *attr)
5279 {
5280         struct nft_expr *expr;
5281         int err;
5282
5283         expr = nft_expr_init(ctx, attr);
5284         if (IS_ERR(expr))
5285                 return expr;
5286
5287         err = -EOPNOTSUPP;
5288         if (!(expr->ops->type->flags & NFT_EXPR_STATEFUL))
5289                 goto err_set_elem_expr;
5290
5291         if (expr->ops->type->flags & NFT_EXPR_GC) {
5292                 if (set->flags & NFT_SET_TIMEOUT)
5293                         goto err_set_elem_expr;
5294                 if (!set->ops->gc_init)
5295                         goto err_set_elem_expr;
5296                 set->ops->gc_init(set);
5297         }
5298
5299         return expr;
5300
5301 err_set_elem_expr:
5302         nft_expr_destroy(ctx, expr);
5303         return ERR_PTR(err);
5304 }
5305
5306 void *nft_set_elem_init(const struct nft_set *set,
5307                         const struct nft_set_ext_tmpl *tmpl,
5308                         const u32 *key, const u32 *key_end,
5309                         const u32 *data, u64 timeout, u64 expiration, gfp_t gfp)
5310 {
5311         struct nft_set_ext *ext;
5312         void *elem;
5313
5314         elem = kzalloc(set->ops->elemsize + tmpl->len, gfp);
5315         if (elem == NULL)
5316                 return NULL;
5317
5318         ext = nft_set_elem_ext(set, elem);
5319         nft_set_ext_init(ext, tmpl);
5320
5321         if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY))
5322                 memcpy(nft_set_ext_key(ext), key, set->klen);
5323         if (nft_set_ext_exists(ext, NFT_SET_EXT_KEY_END))
5324                 memcpy(nft_set_ext_key_end(ext), key_end, set->klen);
5325         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA))
5326                 memcpy(nft_set_ext_data(ext), data, set->dlen);
5327         if (nft_set_ext_exists(ext, NFT_SET_EXT_EXPIRATION)) {
5328                 *nft_set_ext_expiration(ext) = get_jiffies_64() + expiration;
5329                 if (expiration == 0)
5330                         *nft_set_ext_expiration(ext) += timeout;
5331         }
5332         if (nft_set_ext_exists(ext, NFT_SET_EXT_TIMEOUT))
5333                 *nft_set_ext_timeout(ext) = timeout;
5334
5335         return elem;
5336 }
5337
5338 static void __nft_set_elem_expr_destroy(const struct nft_ctx *ctx,
5339                                         struct nft_expr *expr)
5340 {
5341         if (expr->ops->destroy_clone) {
5342                 expr->ops->destroy_clone(ctx, expr);
5343                 module_put(expr->ops->type->owner);
5344         } else {
5345                 nf_tables_expr_destroy(ctx, expr);
5346         }
5347 }
5348
5349 static void nft_set_elem_expr_destroy(const struct nft_ctx *ctx,
5350                                       struct nft_set_elem_expr *elem_expr)
5351 {
5352         struct nft_expr *expr;
5353         u32 size;
5354
5355         nft_setelem_expr_foreach(expr, elem_expr, size)
5356                 __nft_set_elem_expr_destroy(ctx, expr);
5357 }
5358
5359 void nft_set_elem_destroy(const struct nft_set *set, void *elem,
5360                           bool destroy_expr)
5361 {
5362         struct nft_set_ext *ext = nft_set_elem_ext(set, elem);
5363         struct nft_ctx ctx = {
5364                 .net    = read_pnet(&set->net),
5365                 .family = set->table->family,
5366         };
5367
5368         nft_data_release(nft_set_ext_key(ext), NFT_DATA_VALUE);
5369         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA))
5370                 nft_data_release(nft_set_ext_data(ext), set->dtype);
5371         if (destroy_expr && nft_set_ext_exists(ext, NFT_SET_EXT_EXPRESSIONS))
5372                 nft_set_elem_expr_destroy(&ctx, nft_set_ext_expr(ext));
5373
5374         if (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF))
5375                 (*nft_set_ext_obj(ext))->use--;
5376         kfree(elem);
5377 }
5378 EXPORT_SYMBOL_GPL(nft_set_elem_destroy);
5379
5380 /* Only called from commit path, nft_setelem_data_deactivate() already deals
5381  * with the refcounting from the preparation phase.
5382  */
5383 static void nf_tables_set_elem_destroy(const struct nft_ctx *ctx,
5384                                        const struct nft_set *set, void *elem)
5385 {
5386         struct nft_set_ext *ext = nft_set_elem_ext(set, elem);
5387
5388         if (nft_set_ext_exists(ext, NFT_SET_EXT_EXPRESSIONS))
5389                 nft_set_elem_expr_destroy(ctx, nft_set_ext_expr(ext));
5390
5391         kfree(elem);
5392 }
5393
5394 int nft_set_elem_expr_clone(const struct nft_ctx *ctx, struct nft_set *set,
5395                             struct nft_expr *expr_array[])
5396 {
5397         struct nft_expr *expr;
5398         int err, i, k;
5399
5400         for (i = 0; i < set->num_exprs; i++) {
5401                 expr = kzalloc(set->exprs[i]->ops->size, GFP_KERNEL);
5402                 if (!expr)
5403                         goto err_expr;
5404
5405                 err = nft_expr_clone(expr, set->exprs[i]);
5406                 if (err < 0) {
5407                         nft_expr_destroy(ctx, expr);
5408                         goto err_expr;
5409                 }
5410                 expr_array[i] = expr;
5411         }
5412
5413         return 0;
5414
5415 err_expr:
5416         for (k = i - 1; k >= 0; k--)
5417                 nft_expr_destroy(ctx, expr_array[k]);
5418
5419         return -ENOMEM;
5420 }
5421
5422 static int nft_set_elem_expr_setup(struct nft_ctx *ctx,
5423                                    const struct nft_set_ext *ext,
5424                                    struct nft_expr *expr_array[],
5425                                    u32 num_exprs)
5426 {
5427         struct nft_set_elem_expr *elem_expr = nft_set_ext_expr(ext);
5428         struct nft_expr *expr;
5429         int i, err;
5430
5431         for (i = 0; i < num_exprs; i++) {
5432                 expr = nft_setelem_expr_at(elem_expr, elem_expr->size);
5433                 err = nft_expr_clone(expr, expr_array[i]);
5434                 if (err < 0)
5435                         goto err_elem_expr_setup;
5436
5437                 elem_expr->size += expr_array[i]->ops->size;
5438                 nft_expr_destroy(ctx, expr_array[i]);
5439                 expr_array[i] = NULL;
5440         }
5441
5442         return 0;
5443
5444 err_elem_expr_setup:
5445         for (; i < num_exprs; i++) {
5446                 nft_expr_destroy(ctx, expr_array[i]);
5447                 expr_array[i] = NULL;
5448         }
5449
5450         return -ENOMEM;
5451 }
5452
5453 struct nft_set_ext *nft_set_catchall_lookup(const struct net *net,
5454                                             const struct nft_set *set)
5455 {
5456         struct nft_set_elem_catchall *catchall;
5457         u8 genmask = nft_genmask_cur(net);
5458         struct nft_set_ext *ext;
5459
5460         list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
5461                 ext = nft_set_elem_ext(set, catchall->elem);
5462                 if (nft_set_elem_active(ext, genmask) &&
5463                     !nft_set_elem_expired(ext))
5464                         return ext;
5465         }
5466
5467         return NULL;
5468 }
5469 EXPORT_SYMBOL_GPL(nft_set_catchall_lookup);
5470
5471 void *nft_set_catchall_gc(const struct nft_set *set)
5472 {
5473         struct nft_set_elem_catchall *catchall, *next;
5474         struct nft_set_ext *ext;
5475         void *elem = NULL;
5476
5477         list_for_each_entry_safe(catchall, next, &set->catchall_list, list) {
5478                 ext = nft_set_elem_ext(set, catchall->elem);
5479
5480                 if (!nft_set_elem_expired(ext) ||
5481                     nft_set_elem_mark_busy(ext))
5482                         continue;
5483
5484                 elem = catchall->elem;
5485                 list_del_rcu(&catchall->list);
5486                 kfree_rcu(catchall, rcu);
5487                 break;
5488         }
5489
5490         return elem;
5491 }
5492 EXPORT_SYMBOL_GPL(nft_set_catchall_gc);
5493
5494 static int nft_setelem_catchall_insert(const struct net *net,
5495                                        struct nft_set *set,
5496                                        const struct nft_set_elem *elem,
5497                                        struct nft_set_ext **pext)
5498 {
5499         struct nft_set_elem_catchall *catchall;
5500         u8 genmask = nft_genmask_next(net);
5501         struct nft_set_ext *ext;
5502
5503         list_for_each_entry(catchall, &set->catchall_list, list) {
5504                 ext = nft_set_elem_ext(set, catchall->elem);
5505                 if (nft_set_elem_active(ext, genmask)) {
5506                         *pext = ext;
5507                         return -EEXIST;
5508                 }
5509         }
5510
5511         catchall = kmalloc(sizeof(*catchall), GFP_KERNEL);
5512         if (!catchall)
5513                 return -ENOMEM;
5514
5515         catchall->elem = elem->priv;
5516         list_add_tail_rcu(&catchall->list, &set->catchall_list);
5517
5518         return 0;
5519 }
5520
5521 static int nft_setelem_insert(const struct net *net,
5522                               struct nft_set *set,
5523                               const struct nft_set_elem *elem,
5524                               struct nft_set_ext **ext, unsigned int flags)
5525 {
5526         int ret;
5527
5528         if (flags & NFT_SET_ELEM_CATCHALL)
5529                 ret = nft_setelem_catchall_insert(net, set, elem, ext);
5530         else
5531                 ret = set->ops->insert(net, set, elem, ext);
5532
5533         return ret;
5534 }
5535
5536 static bool nft_setelem_is_catchall(const struct nft_set *set,
5537                                     const struct nft_set_elem *elem)
5538 {
5539         struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
5540
5541         if (nft_set_ext_exists(ext, NFT_SET_EXT_FLAGS) &&
5542             *nft_set_ext_flags(ext) & NFT_SET_ELEM_CATCHALL)
5543                 return true;
5544
5545         return false;
5546 }
5547
5548 static void nft_setelem_activate(struct net *net, struct nft_set *set,
5549                                  struct nft_set_elem *elem)
5550 {
5551         struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
5552
5553         if (nft_setelem_is_catchall(set, elem)) {
5554                 nft_set_elem_change_active(net, set, ext);
5555                 nft_set_elem_clear_busy(ext);
5556         } else {
5557                 set->ops->activate(net, set, elem);
5558         }
5559 }
5560
5561 static int nft_setelem_catchall_deactivate(const struct net *net,
5562                                            struct nft_set *set,
5563                                            struct nft_set_elem *elem)
5564 {
5565         struct nft_set_elem_catchall *catchall;
5566         struct nft_set_ext *ext;
5567
5568         list_for_each_entry(catchall, &set->catchall_list, list) {
5569                 ext = nft_set_elem_ext(set, catchall->elem);
5570                 if (!nft_is_active(net, ext) ||
5571                     nft_set_elem_mark_busy(ext))
5572                         continue;
5573
5574                 kfree(elem->priv);
5575                 elem->priv = catchall->elem;
5576                 nft_set_elem_change_active(net, set, ext);
5577                 return 0;
5578         }
5579
5580         return -ENOENT;
5581 }
5582
5583 static int __nft_setelem_deactivate(const struct net *net,
5584                                     struct nft_set *set,
5585                                     struct nft_set_elem *elem)
5586 {
5587         void *priv;
5588
5589         priv = set->ops->deactivate(net, set, elem);
5590         if (!priv)
5591                 return -ENOENT;
5592
5593         kfree(elem->priv);
5594         elem->priv = priv;
5595         set->ndeact++;
5596
5597         return 0;
5598 }
5599
5600 static int nft_setelem_deactivate(const struct net *net,
5601                                   struct nft_set *set,
5602                                   struct nft_set_elem *elem, u32 flags)
5603 {
5604         int ret;
5605
5606         if (flags & NFT_SET_ELEM_CATCHALL)
5607                 ret = nft_setelem_catchall_deactivate(net, set, elem);
5608         else
5609                 ret = __nft_setelem_deactivate(net, set, elem);
5610
5611         return ret;
5612 }
5613
5614 static void nft_setelem_catchall_remove(const struct net *net,
5615                                         const struct nft_set *set,
5616                                         const struct nft_set_elem *elem)
5617 {
5618         struct nft_set_elem_catchall *catchall, *next;
5619
5620         list_for_each_entry_safe(catchall, next, &set->catchall_list, list) {
5621                 if (catchall->elem == elem->priv) {
5622                         list_del_rcu(&catchall->list);
5623                         kfree_rcu(catchall);
5624                         break;
5625                 }
5626         }
5627 }
5628
5629 static void nft_setelem_remove(const struct net *net,
5630                                const struct nft_set *set,
5631                                const struct nft_set_elem *elem)
5632 {
5633         if (nft_setelem_is_catchall(set, elem))
5634                 nft_setelem_catchall_remove(net, set, elem);
5635         else
5636                 set->ops->remove(net, set, elem);
5637 }
5638
5639 static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set,
5640                             const struct nlattr *attr, u32 nlmsg_flags)
5641 {
5642         struct nft_expr *expr_array[NFT_SET_EXPR_MAX] = {};
5643         struct nlattr *nla[NFTA_SET_ELEM_MAX + 1];
5644         u8 genmask = nft_genmask_next(ctx->net);
5645         u32 flags = 0, size = 0, num_exprs = 0;
5646         struct nft_set_ext_tmpl tmpl;
5647         struct nft_set_ext *ext, *ext2;
5648         struct nft_set_elem elem;
5649         struct nft_set_binding *binding;
5650         struct nft_object *obj = NULL;
5651         struct nft_userdata *udata;
5652         struct nft_data_desc desc;
5653         enum nft_registers dreg;
5654         struct nft_trans *trans;
5655         u64 timeout;
5656         u64 expiration;
5657         int err, i;
5658         u8 ulen;
5659
5660         err = nla_parse_nested_deprecated(nla, NFTA_SET_ELEM_MAX, attr,
5661                                           nft_set_elem_policy, NULL);
5662         if (err < 0)
5663                 return err;
5664
5665         nft_set_ext_prepare(&tmpl);
5666
5667         err = nft_setelem_parse_flags(set, nla[NFTA_SET_ELEM_FLAGS], &flags);
5668         if (err < 0)
5669                 return err;
5670
5671         if (!nla[NFTA_SET_ELEM_KEY] && !(flags & NFT_SET_ELEM_CATCHALL))
5672                 return -EINVAL;
5673
5674         if (flags != 0)
5675                 nft_set_ext_add(&tmpl, NFT_SET_EXT_FLAGS);
5676
5677         if (set->flags & NFT_SET_MAP) {
5678                 if (nla[NFTA_SET_ELEM_DATA] == NULL &&
5679                     !(flags & NFT_SET_ELEM_INTERVAL_END))
5680                         return -EINVAL;
5681         } else {
5682                 if (nla[NFTA_SET_ELEM_DATA] != NULL)
5683                         return -EINVAL;
5684         }
5685
5686         if ((flags & NFT_SET_ELEM_INTERVAL_END) &&
5687              (nla[NFTA_SET_ELEM_DATA] ||
5688               nla[NFTA_SET_ELEM_OBJREF] ||
5689               nla[NFTA_SET_ELEM_TIMEOUT] ||
5690               nla[NFTA_SET_ELEM_EXPIRATION] ||
5691               nla[NFTA_SET_ELEM_USERDATA] ||
5692               nla[NFTA_SET_ELEM_EXPR] ||
5693               nla[NFTA_SET_ELEM_EXPRESSIONS]))
5694                 return -EINVAL;
5695
5696         timeout = 0;
5697         if (nla[NFTA_SET_ELEM_TIMEOUT] != NULL) {
5698                 if (!(set->flags & NFT_SET_TIMEOUT))
5699                         return -EINVAL;
5700                 err = nf_msecs_to_jiffies64(nla[NFTA_SET_ELEM_TIMEOUT],
5701                                             &timeout);
5702                 if (err)
5703                         return err;
5704         } else if (set->flags & NFT_SET_TIMEOUT) {
5705                 timeout = set->timeout;
5706         }
5707
5708         expiration = 0;
5709         if (nla[NFTA_SET_ELEM_EXPIRATION] != NULL) {
5710                 if (!(set->flags & NFT_SET_TIMEOUT))
5711                         return -EINVAL;
5712                 err = nf_msecs_to_jiffies64(nla[NFTA_SET_ELEM_EXPIRATION],
5713                                             &expiration);
5714                 if (err)
5715                         return err;
5716         }
5717
5718         if (nla[NFTA_SET_ELEM_EXPR]) {
5719                 struct nft_expr *expr;
5720
5721                 if (set->num_exprs && set->num_exprs != 1)
5722                         return -EOPNOTSUPP;
5723
5724                 expr = nft_set_elem_expr_alloc(ctx, set,
5725                                                nla[NFTA_SET_ELEM_EXPR]);
5726                 if (IS_ERR(expr))
5727                         return PTR_ERR(expr);
5728
5729                 expr_array[0] = expr;
5730                 num_exprs = 1;
5731
5732                 if (set->num_exprs && set->exprs[0]->ops != expr->ops) {
5733                         err = -EOPNOTSUPP;
5734                         goto err_set_elem_expr;
5735                 }
5736         } else if (nla[NFTA_SET_ELEM_EXPRESSIONS]) {
5737                 struct nft_expr *expr;
5738                 struct nlattr *tmp;
5739                 int left;
5740
5741                 i = 0;
5742                 nla_for_each_nested(tmp, nla[NFTA_SET_ELEM_EXPRESSIONS], left) {
5743                         if (i == NFT_SET_EXPR_MAX ||
5744                             (set->num_exprs && set->num_exprs == i)) {
5745                                 err = -E2BIG;
5746                                 goto err_set_elem_expr;
5747                         }
5748                         if (nla_type(tmp) != NFTA_LIST_ELEM) {
5749                                 err = -EINVAL;
5750                                 goto err_set_elem_expr;
5751                         }
5752                         expr = nft_set_elem_expr_alloc(ctx, set, tmp);
5753                         if (IS_ERR(expr)) {
5754                                 err = PTR_ERR(expr);
5755                                 goto err_set_elem_expr;
5756                         }
5757                         expr_array[i] = expr;
5758                         num_exprs++;
5759
5760                         if (set->num_exprs && expr->ops != set->exprs[i]->ops) {
5761                                 err = -EOPNOTSUPP;
5762                                 goto err_set_elem_expr;
5763                         }
5764                         i++;
5765                 }
5766                 if (set->num_exprs && set->num_exprs != i) {
5767                         err = -EOPNOTSUPP;
5768                         goto err_set_elem_expr;
5769                 }
5770         } else if (set->num_exprs > 0) {
5771                 err = nft_set_elem_expr_clone(ctx, set, expr_array);
5772                 if (err < 0)
5773                         goto err_set_elem_expr_clone;
5774
5775                 num_exprs = set->num_exprs;
5776         }
5777
5778         if (nla[NFTA_SET_ELEM_KEY]) {
5779                 err = nft_setelem_parse_key(ctx, set, &elem.key.val,
5780                                             nla[NFTA_SET_ELEM_KEY]);
5781                 if (err < 0)
5782                         goto err_set_elem_expr;
5783
5784                 nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY, set->klen);
5785         }
5786
5787         if (nla[NFTA_SET_ELEM_KEY_END]) {
5788                 err = nft_setelem_parse_key(ctx, set, &elem.key_end.val,
5789                                             nla[NFTA_SET_ELEM_KEY_END]);
5790                 if (err < 0)
5791                         goto err_parse_key;
5792
5793                 nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY_END, set->klen);
5794         }
5795
5796         if (timeout > 0) {
5797                 nft_set_ext_add(&tmpl, NFT_SET_EXT_EXPIRATION);
5798                 if (timeout != set->timeout)
5799                         nft_set_ext_add(&tmpl, NFT_SET_EXT_TIMEOUT);
5800         }
5801
5802         if (num_exprs) {
5803                 for (i = 0; i < num_exprs; i++)
5804                         size += expr_array[i]->ops->size;
5805
5806                 nft_set_ext_add_length(&tmpl, NFT_SET_EXT_EXPRESSIONS,
5807                                        sizeof(struct nft_set_elem_expr) +
5808                                        size);
5809         }
5810
5811         if (nla[NFTA_SET_ELEM_OBJREF] != NULL) {
5812                 if (!(set->flags & NFT_SET_OBJECT)) {
5813                         err = -EINVAL;
5814                         goto err_parse_key_end;
5815                 }
5816                 obj = nft_obj_lookup(ctx->net, ctx->table,
5817                                      nla[NFTA_SET_ELEM_OBJREF],
5818                                      set->objtype, genmask);
5819                 if (IS_ERR(obj)) {
5820                         err = PTR_ERR(obj);
5821                         goto err_parse_key_end;
5822                 }
5823                 nft_set_ext_add(&tmpl, NFT_SET_EXT_OBJREF);
5824         }
5825
5826         if (nla[NFTA_SET_ELEM_DATA] != NULL) {
5827                 err = nft_setelem_parse_data(ctx, set, &desc, &elem.data.val,
5828                                              nla[NFTA_SET_ELEM_DATA]);
5829                 if (err < 0)
5830                         goto err_parse_key_end;
5831
5832                 dreg = nft_type_to_reg(set->dtype);
5833                 list_for_each_entry(binding, &set->bindings, list) {
5834                         struct nft_ctx bind_ctx = {
5835                                 .net    = ctx->net,
5836                                 .family = ctx->family,
5837                                 .table  = ctx->table,
5838                                 .chain  = (struct nft_chain *)binding->chain,
5839                         };
5840
5841                         if (!(binding->flags & NFT_SET_MAP))
5842                                 continue;
5843
5844                         err = nft_validate_register_store(&bind_ctx, dreg,
5845                                                           &elem.data.val,
5846                                                           desc.type, desc.len);
5847                         if (err < 0)
5848                                 goto err_parse_data;
5849
5850                         if (desc.type == NFT_DATA_VERDICT &&
5851                             (elem.data.val.verdict.code == NFT_GOTO ||
5852                              elem.data.val.verdict.code == NFT_JUMP))
5853                                 nft_validate_state_update(ctx->net,
5854                                                           NFT_VALIDATE_NEED);
5855                 }
5856
5857                 nft_set_ext_add_length(&tmpl, NFT_SET_EXT_DATA, desc.len);
5858         }
5859
5860         /* The full maximum length of userdata can exceed the maximum
5861          * offset value (U8_MAX) for following extensions, therefor it
5862          * must be the last extension added.
5863          */
5864         ulen = 0;
5865         if (nla[NFTA_SET_ELEM_USERDATA] != NULL) {
5866                 ulen = nla_len(nla[NFTA_SET_ELEM_USERDATA]);
5867                 if (ulen > 0)
5868                         nft_set_ext_add_length(&tmpl, NFT_SET_EXT_USERDATA,
5869                                                ulen);
5870         }
5871
5872         err = -ENOMEM;
5873         elem.priv = nft_set_elem_init(set, &tmpl, elem.key.val.data,
5874                                       elem.key_end.val.data, elem.data.val.data,
5875                                       timeout, expiration, GFP_KERNEL);
5876         if (elem.priv == NULL)
5877                 goto err_parse_data;
5878
5879         ext = nft_set_elem_ext(set, elem.priv);
5880         if (flags)
5881                 *nft_set_ext_flags(ext) = flags;
5882         if (ulen > 0) {
5883                 udata = nft_set_ext_userdata(ext);
5884                 udata->len = ulen - 1;
5885                 nla_memcpy(&udata->data, nla[NFTA_SET_ELEM_USERDATA], ulen);
5886         }
5887         if (obj) {
5888                 *nft_set_ext_obj(ext) = obj;
5889                 obj->use++;
5890         }
5891         err = nft_set_elem_expr_setup(ctx, ext, expr_array, num_exprs);
5892         if (err < 0)
5893                 goto err_elem_expr;
5894
5895         trans = nft_trans_elem_alloc(ctx, NFT_MSG_NEWSETELEM, set);
5896         if (trans == NULL) {
5897                 err = -ENOMEM;
5898                 goto err_elem_expr;
5899         }
5900
5901         ext->genmask = nft_genmask_cur(ctx->net) | NFT_SET_ELEM_BUSY_MASK;
5902
5903         err = nft_setelem_insert(ctx->net, set, &elem, &ext2, flags);
5904         if (err) {
5905                 if (err == -EEXIST) {
5906                         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA) ^
5907                             nft_set_ext_exists(ext2, NFT_SET_EXT_DATA) ||
5908                             nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF) ^
5909                             nft_set_ext_exists(ext2, NFT_SET_EXT_OBJREF))
5910                                 goto err_element_clash;
5911                         if ((nft_set_ext_exists(ext, NFT_SET_EXT_DATA) &&
5912                              nft_set_ext_exists(ext2, NFT_SET_EXT_DATA) &&
5913                              memcmp(nft_set_ext_data(ext),
5914                                     nft_set_ext_data(ext2), set->dlen) != 0) ||
5915                             (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF) &&
5916                              nft_set_ext_exists(ext2, NFT_SET_EXT_OBJREF) &&
5917                              *nft_set_ext_obj(ext) != *nft_set_ext_obj(ext2)))
5918                                 goto err_element_clash;
5919                         else if (!(nlmsg_flags & NLM_F_EXCL))
5920                                 err = 0;
5921                 } else if (err == -ENOTEMPTY) {
5922                         /* ENOTEMPTY reports overlapping between this element
5923                          * and an existing one.
5924                          */
5925                         err = -EEXIST;
5926                 }
5927                 goto err_element_clash;
5928         }
5929
5930         if (!(flags & NFT_SET_ELEM_CATCHALL) && set->size &&
5931             !atomic_add_unless(&set->nelems, 1, set->size + set->ndeact)) {
5932                 err = -ENFILE;
5933                 goto err_set_full;
5934         }
5935
5936         nft_trans_elem(trans) = elem;
5937         nft_trans_commit_list_add_tail(ctx->net, trans);
5938         return 0;
5939
5940 err_set_full:
5941         nft_setelem_remove(ctx->net, set, &elem);
5942 err_element_clash:
5943         kfree(trans);
5944 err_elem_expr:
5945         if (obj)
5946                 obj->use--;
5947
5948         nf_tables_set_elem_destroy(ctx, set, elem.priv);
5949 err_parse_data:
5950         if (nla[NFTA_SET_ELEM_DATA] != NULL)
5951                 nft_data_release(&elem.data.val, desc.type);
5952 err_parse_key_end:
5953         nft_data_release(&elem.key_end.val, NFT_DATA_VALUE);
5954 err_parse_key:
5955         nft_data_release(&elem.key.val, NFT_DATA_VALUE);
5956 err_set_elem_expr:
5957         for (i = 0; i < num_exprs && expr_array[i]; i++)
5958                 nft_expr_destroy(ctx, expr_array[i]);
5959 err_set_elem_expr_clone:
5960         return err;
5961 }
5962
5963 static int nf_tables_newsetelem(struct sk_buff *skb,
5964                                 const struct nfnl_info *info,
5965                                 const struct nlattr * const nla[])
5966 {
5967         struct nftables_pernet *nft_net = nft_pernet(info->net);
5968         struct netlink_ext_ack *extack = info->extack;
5969         u8 genmask = nft_genmask_next(info->net);
5970         u8 family = info->nfmsg->nfgen_family;
5971         struct net *net = info->net;
5972         const struct nlattr *attr;
5973         struct nft_table *table;
5974         struct nft_set *set;
5975         struct nft_ctx ctx;
5976         int rem, err;
5977
5978         if (nla[NFTA_SET_ELEM_LIST_ELEMENTS] == NULL)
5979                 return -EINVAL;
5980
5981         table = nft_table_lookup(net, nla[NFTA_SET_ELEM_LIST_TABLE], family,
5982                                  genmask, NETLINK_CB(skb).portid);
5983         if (IS_ERR(table)) {
5984                 NL_SET_BAD_ATTR(extack, nla[NFTA_SET_ELEM_LIST_TABLE]);
5985                 return PTR_ERR(table);
5986         }
5987
5988         set = nft_set_lookup_global(net, table, nla[NFTA_SET_ELEM_LIST_SET],
5989                                     nla[NFTA_SET_ELEM_LIST_SET_ID], genmask);
5990         if (IS_ERR(set))
5991                 return PTR_ERR(set);
5992
5993         if (!list_empty(&set->bindings) && set->flags & NFT_SET_CONSTANT)
5994                 return -EBUSY;
5995
5996         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
5997
5998         nla_for_each_nested(attr, nla[NFTA_SET_ELEM_LIST_ELEMENTS], rem) {
5999                 err = nft_add_set_elem(&ctx, set, attr, info->nlh->nlmsg_flags);
6000                 if (err < 0)
6001                         return err;
6002         }
6003
6004         if (nft_net->validate_state == NFT_VALIDATE_DO)
6005                 return nft_table_validate(net, table);
6006
6007         return 0;
6008 }
6009
6010 /**
6011  *      nft_data_hold - hold a nft_data item
6012  *
6013  *      @data: struct nft_data to release
6014  *      @type: type of data
6015  *
6016  *      Hold a nft_data item. NFT_DATA_VALUE types can be silently discarded,
6017  *      NFT_DATA_VERDICT bumps the reference to chains in case of NFT_JUMP and
6018  *      NFT_GOTO verdicts. This function must be called on active data objects
6019  *      from the second phase of the commit protocol.
6020  */
6021 void nft_data_hold(const struct nft_data *data, enum nft_data_types type)
6022 {
6023         struct nft_chain *chain;
6024         struct nft_rule *rule;
6025
6026         if (type == NFT_DATA_VERDICT) {
6027                 switch (data->verdict.code) {
6028                 case NFT_JUMP:
6029                 case NFT_GOTO:
6030                         chain = data->verdict.chain;
6031                         chain->use++;
6032
6033                         if (!nft_chain_is_bound(chain))
6034                                 break;
6035
6036                         chain->table->use++;
6037                         list_for_each_entry(rule, &chain->rules, list)
6038                                 chain->use++;
6039
6040                         nft_chain_add(chain->table, chain);
6041                         break;
6042                 }
6043         }
6044 }
6045
6046 static void nft_setelem_data_activate(const struct net *net,
6047                                       const struct nft_set *set,
6048                                       struct nft_set_elem *elem)
6049 {
6050         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
6051
6052         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA))
6053                 nft_data_hold(nft_set_ext_data(ext), set->dtype);
6054         if (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF))
6055                 (*nft_set_ext_obj(ext))->use++;
6056 }
6057
6058 static void nft_setelem_data_deactivate(const struct net *net,
6059                                         const struct nft_set *set,
6060                                         struct nft_set_elem *elem)
6061 {
6062         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
6063
6064         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA))
6065                 nft_data_release(nft_set_ext_data(ext), set->dtype);
6066         if (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF))
6067                 (*nft_set_ext_obj(ext))->use--;
6068 }
6069
6070 static int nft_del_setelem(struct nft_ctx *ctx, struct nft_set *set,
6071                            const struct nlattr *attr)
6072 {
6073         struct nlattr *nla[NFTA_SET_ELEM_MAX + 1];
6074         struct nft_set_ext_tmpl tmpl;
6075         struct nft_set_elem elem;
6076         struct nft_set_ext *ext;
6077         struct nft_trans *trans;
6078         u32 flags = 0;
6079         int err;
6080
6081         err = nla_parse_nested_deprecated(nla, NFTA_SET_ELEM_MAX, attr,
6082                                           nft_set_elem_policy, NULL);
6083         if (err < 0)
6084                 return err;
6085
6086         err = nft_setelem_parse_flags(set, nla[NFTA_SET_ELEM_FLAGS], &flags);
6087         if (err < 0)
6088                 return err;
6089
6090         if (!nla[NFTA_SET_ELEM_KEY] && !(flags & NFT_SET_ELEM_CATCHALL))
6091                 return -EINVAL;
6092
6093         nft_set_ext_prepare(&tmpl);
6094
6095         if (flags != 0)
6096                 nft_set_ext_add(&tmpl, NFT_SET_EXT_FLAGS);
6097
6098         if (nla[NFTA_SET_ELEM_KEY]) {
6099                 err = nft_setelem_parse_key(ctx, set, &elem.key.val,
6100                                             nla[NFTA_SET_ELEM_KEY]);
6101                 if (err < 0)
6102                         return err;
6103
6104                 nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY, set->klen);
6105         }
6106
6107         if (nla[NFTA_SET_ELEM_KEY_END]) {
6108                 err = nft_setelem_parse_key(ctx, set, &elem.key_end.val,
6109                                             nla[NFTA_SET_ELEM_KEY_END]);
6110                 if (err < 0)
6111                         return err;
6112
6113                 nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY_END, set->klen);
6114         }
6115
6116         err = -ENOMEM;
6117         elem.priv = nft_set_elem_init(set, &tmpl, elem.key.val.data,
6118                                       elem.key_end.val.data, NULL, 0, 0,
6119                                       GFP_KERNEL);
6120         if (elem.priv == NULL)
6121                 goto fail_elem;
6122
6123         ext = nft_set_elem_ext(set, elem.priv);
6124         if (flags)
6125                 *nft_set_ext_flags(ext) = flags;
6126
6127         trans = nft_trans_elem_alloc(ctx, NFT_MSG_DELSETELEM, set);
6128         if (trans == NULL)
6129                 goto fail_trans;
6130
6131         err = nft_setelem_deactivate(ctx->net, set, &elem, flags);
6132         if (err < 0)
6133                 goto fail_ops;
6134
6135         nft_setelem_data_deactivate(ctx->net, set, &elem);
6136
6137         nft_trans_elem(trans) = elem;
6138         nft_trans_commit_list_add_tail(ctx->net, trans);
6139         return 0;
6140
6141 fail_ops:
6142         kfree(trans);
6143 fail_trans:
6144         kfree(elem.priv);
6145 fail_elem:
6146         nft_data_release(&elem.key.val, NFT_DATA_VALUE);
6147         return err;
6148 }
6149
6150 static int nft_setelem_flush(const struct nft_ctx *ctx,
6151                              struct nft_set *set,
6152                              const struct nft_set_iter *iter,
6153                              struct nft_set_elem *elem)
6154 {
6155         struct nft_trans *trans;
6156         int err;
6157
6158         trans = nft_trans_alloc_gfp(ctx, NFT_MSG_DELSETELEM,
6159                                     sizeof(struct nft_trans_elem), GFP_ATOMIC);
6160         if (!trans)
6161                 return -ENOMEM;
6162
6163         if (!set->ops->flush(ctx->net, set, elem->priv)) {
6164                 err = -ENOENT;
6165                 goto err1;
6166         }
6167         set->ndeact++;
6168
6169         nft_setelem_data_deactivate(ctx->net, set, elem);
6170         nft_trans_elem_set(trans) = set;
6171         nft_trans_elem(trans) = *elem;
6172         nft_trans_commit_list_add_tail(ctx->net, trans);
6173
6174         return 0;
6175 err1:
6176         kfree(trans);
6177         return err;
6178 }
6179
6180 static int __nft_set_catchall_flush(const struct nft_ctx *ctx,
6181                                     struct nft_set *set,
6182                                     struct nft_set_elem *elem)
6183 {
6184         struct nft_trans *trans;
6185
6186         trans = nft_trans_alloc_gfp(ctx, NFT_MSG_DELSETELEM,
6187                                     sizeof(struct nft_trans_elem), GFP_KERNEL);
6188         if (!trans)
6189                 return -ENOMEM;
6190
6191         nft_setelem_data_deactivate(ctx->net, set, elem);
6192         nft_trans_elem_set(trans) = set;
6193         nft_trans_elem(trans) = *elem;
6194         nft_trans_commit_list_add_tail(ctx->net, trans);
6195
6196         return 0;
6197 }
6198
6199 static int nft_set_catchall_flush(const struct nft_ctx *ctx,
6200                                   struct nft_set *set)
6201 {
6202         u8 genmask = nft_genmask_next(ctx->net);
6203         struct nft_set_elem_catchall *catchall;
6204         struct nft_set_elem elem;
6205         struct nft_set_ext *ext;
6206         int ret = 0;
6207
6208         list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
6209                 ext = nft_set_elem_ext(set, catchall->elem);
6210                 if (!nft_set_elem_active(ext, genmask) ||
6211                     nft_set_elem_mark_busy(ext))
6212                         continue;
6213
6214                 elem.priv = catchall->elem;
6215                 ret = __nft_set_catchall_flush(ctx, set, &elem);
6216                 if (ret < 0)
6217                         break;
6218         }
6219
6220         return ret;
6221 }
6222
6223 static int nft_set_flush(struct nft_ctx *ctx, struct nft_set *set, u8 genmask)
6224 {
6225         struct nft_set_iter iter = {
6226                 .genmask        = genmask,
6227                 .fn             = nft_setelem_flush,
6228         };
6229
6230         set->ops->walk(ctx, set, &iter);
6231         if (!iter.err)
6232                 iter.err = nft_set_catchall_flush(ctx, set);
6233
6234         return iter.err;
6235 }
6236
6237 static int nf_tables_delsetelem(struct sk_buff *skb,
6238                                 const struct nfnl_info *info,
6239                                 const struct nlattr * const nla[])
6240 {
6241         struct netlink_ext_ack *extack = info->extack;
6242         u8 genmask = nft_genmask_next(info->net);
6243         u8 family = info->nfmsg->nfgen_family;
6244         struct net *net = info->net;
6245         const struct nlattr *attr;
6246         struct nft_table *table;
6247         struct nft_set *set;
6248         struct nft_ctx ctx;
6249         int rem, err = 0;
6250
6251         table = nft_table_lookup(net, nla[NFTA_SET_ELEM_LIST_TABLE], family,
6252                                  genmask, NETLINK_CB(skb).portid);
6253         if (IS_ERR(table)) {
6254                 NL_SET_BAD_ATTR(extack, nla[NFTA_SET_ELEM_LIST_TABLE]);
6255                 return PTR_ERR(table);
6256         }
6257
6258         set = nft_set_lookup(table, nla[NFTA_SET_ELEM_LIST_SET], genmask);
6259         if (IS_ERR(set))
6260                 return PTR_ERR(set);
6261         if (!list_empty(&set->bindings) && set->flags & NFT_SET_CONSTANT)
6262                 return -EBUSY;
6263
6264         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
6265
6266         if (!nla[NFTA_SET_ELEM_LIST_ELEMENTS])
6267                 return nft_set_flush(&ctx, set, genmask);
6268
6269         nla_for_each_nested(attr, nla[NFTA_SET_ELEM_LIST_ELEMENTS], rem) {
6270                 err = nft_del_setelem(&ctx, set, attr);
6271                 if (err < 0)
6272                         break;
6273         }
6274         return err;
6275 }
6276
6277 void nft_set_gc_batch_release(struct rcu_head *rcu)
6278 {
6279         struct nft_set_gc_batch *gcb;
6280         unsigned int i;
6281
6282         gcb = container_of(rcu, struct nft_set_gc_batch, head.rcu);
6283         for (i = 0; i < gcb->head.cnt; i++)
6284                 nft_set_elem_destroy(gcb->head.set, gcb->elems[i], true);
6285         kfree(gcb);
6286 }
6287
6288 struct nft_set_gc_batch *nft_set_gc_batch_alloc(const struct nft_set *set,
6289                                                 gfp_t gfp)
6290 {
6291         struct nft_set_gc_batch *gcb;
6292
6293         gcb = kzalloc(sizeof(*gcb), gfp);
6294         if (gcb == NULL)
6295                 return gcb;
6296         gcb->head.set = set;
6297         return gcb;
6298 }
6299
6300 /*
6301  * Stateful objects
6302  */
6303
6304 /**
6305  *      nft_register_obj- register nf_tables stateful object type
6306  *      @obj_type: object type
6307  *
6308  *      Registers the object type for use with nf_tables. Returns zero on
6309  *      success or a negative errno code otherwise.
6310  */
6311 int nft_register_obj(struct nft_object_type *obj_type)
6312 {
6313         if (obj_type->type == NFT_OBJECT_UNSPEC)
6314                 return -EINVAL;
6315
6316         nfnl_lock(NFNL_SUBSYS_NFTABLES);
6317         list_add_rcu(&obj_type->list, &nf_tables_objects);
6318         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
6319         return 0;
6320 }
6321 EXPORT_SYMBOL_GPL(nft_register_obj);
6322
6323 /**
6324  *      nft_unregister_obj - unregister nf_tables object type
6325  *      @obj_type: object type
6326  *
6327  *      Unregisters the object type for use with nf_tables.
6328  */
6329 void nft_unregister_obj(struct nft_object_type *obj_type)
6330 {
6331         nfnl_lock(NFNL_SUBSYS_NFTABLES);
6332         list_del_rcu(&obj_type->list);
6333         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
6334 }
6335 EXPORT_SYMBOL_GPL(nft_unregister_obj);
6336
6337 struct nft_object *nft_obj_lookup(const struct net *net,
6338                                   const struct nft_table *table,
6339                                   const struct nlattr *nla, u32 objtype,
6340                                   u8 genmask)
6341 {
6342         struct nft_object_hash_key k = { .table = table };
6343         char search[NFT_OBJ_MAXNAMELEN];
6344         struct rhlist_head *tmp, *list;
6345         struct nft_object *obj;
6346
6347         nla_strscpy(search, nla, sizeof(search));
6348         k.name = search;
6349
6350         WARN_ON_ONCE(!rcu_read_lock_held() &&
6351                      !lockdep_commit_lock_is_held(net));
6352
6353         rcu_read_lock();
6354         list = rhltable_lookup(&nft_objname_ht, &k, nft_objname_ht_params);
6355         if (!list)
6356                 goto out;
6357
6358         rhl_for_each_entry_rcu(obj, tmp, list, rhlhead) {
6359                 if (objtype == obj->ops->type->type &&
6360                     nft_active_genmask(obj, genmask)) {
6361                         rcu_read_unlock();
6362                         return obj;
6363                 }
6364         }
6365 out:
6366         rcu_read_unlock();
6367         return ERR_PTR(-ENOENT);
6368 }
6369 EXPORT_SYMBOL_GPL(nft_obj_lookup);
6370
6371 static struct nft_object *nft_obj_lookup_byhandle(const struct nft_table *table,
6372                                                   const struct nlattr *nla,
6373                                                   u32 objtype, u8 genmask)
6374 {
6375         struct nft_object *obj;
6376
6377         list_for_each_entry(obj, &table->objects, list) {
6378                 if (be64_to_cpu(nla_get_be64(nla)) == obj->handle &&
6379                     objtype == obj->ops->type->type &&
6380                     nft_active_genmask(obj, genmask))
6381                         return obj;
6382         }
6383         return ERR_PTR(-ENOENT);
6384 }
6385
6386 static const struct nla_policy nft_obj_policy[NFTA_OBJ_MAX + 1] = {
6387         [NFTA_OBJ_TABLE]        = { .type = NLA_STRING,
6388                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
6389         [NFTA_OBJ_NAME]         = { .type = NLA_STRING,
6390                                     .len = NFT_OBJ_MAXNAMELEN - 1 },
6391         [NFTA_OBJ_TYPE]         = { .type = NLA_U32 },
6392         [NFTA_OBJ_DATA]         = { .type = NLA_NESTED },
6393         [NFTA_OBJ_HANDLE]       = { .type = NLA_U64},
6394         [NFTA_OBJ_USERDATA]     = { .type = NLA_BINARY,
6395                                     .len = NFT_USERDATA_MAXLEN },
6396 };
6397
6398 static struct nft_object *nft_obj_init(const struct nft_ctx *ctx,
6399                                        const struct nft_object_type *type,
6400                                        const struct nlattr *attr)
6401 {
6402         struct nlattr **tb;
6403         const struct nft_object_ops *ops;
6404         struct nft_object *obj;
6405         int err = -ENOMEM;
6406
6407         tb = kmalloc_array(type->maxattr + 1, sizeof(*tb), GFP_KERNEL);
6408         if (!tb)
6409                 goto err1;
6410
6411         if (attr) {
6412                 err = nla_parse_nested_deprecated(tb, type->maxattr, attr,
6413                                                   type->policy, NULL);
6414                 if (err < 0)
6415                         goto err2;
6416         } else {
6417                 memset(tb, 0, sizeof(tb[0]) * (type->maxattr + 1));
6418         }
6419
6420         if (type->select_ops) {
6421                 ops = type->select_ops(ctx, (const struct nlattr * const *)tb);
6422                 if (IS_ERR(ops)) {
6423                         err = PTR_ERR(ops);
6424                         goto err2;
6425                 }
6426         } else {
6427                 ops = type->ops;
6428         }
6429
6430         err = -ENOMEM;
6431         obj = kzalloc(sizeof(*obj) + ops->size, GFP_KERNEL);
6432         if (!obj)
6433                 goto err2;
6434
6435         err = ops->init(ctx, (const struct nlattr * const *)tb, obj);
6436         if (err < 0)
6437                 goto err3;
6438
6439         obj->ops = ops;
6440
6441         kfree(tb);
6442         return obj;
6443 err3:
6444         kfree(obj);
6445 err2:
6446         kfree(tb);
6447 err1:
6448         return ERR_PTR(err);
6449 }
6450
6451 static int nft_object_dump(struct sk_buff *skb, unsigned int attr,
6452                            struct nft_object *obj, bool reset)
6453 {
6454         struct nlattr *nest;
6455
6456         nest = nla_nest_start_noflag(skb, attr);
6457         if (!nest)
6458                 goto nla_put_failure;
6459         if (obj->ops->dump(skb, obj, reset) < 0)
6460                 goto nla_put_failure;
6461         nla_nest_end(skb, nest);
6462         return 0;
6463
6464 nla_put_failure:
6465         return -1;
6466 }
6467
6468 static const struct nft_object_type *__nft_obj_type_get(u32 objtype)
6469 {
6470         const struct nft_object_type *type;
6471
6472         list_for_each_entry(type, &nf_tables_objects, list) {
6473                 if (objtype == type->type)
6474                         return type;
6475         }
6476         return NULL;
6477 }
6478
6479 static const struct nft_object_type *
6480 nft_obj_type_get(struct net *net, u32 objtype)
6481 {
6482         const struct nft_object_type *type;
6483
6484         type = __nft_obj_type_get(objtype);
6485         if (type != NULL && try_module_get(type->owner))
6486                 return type;
6487
6488         lockdep_nfnl_nft_mutex_not_held();
6489 #ifdef CONFIG_MODULES
6490         if (type == NULL) {
6491                 if (nft_request_module(net, "nft-obj-%u", objtype) == -EAGAIN)
6492                         return ERR_PTR(-EAGAIN);
6493         }
6494 #endif
6495         return ERR_PTR(-ENOENT);
6496 }
6497
6498 static int nf_tables_updobj(const struct nft_ctx *ctx,
6499                             const struct nft_object_type *type,
6500                             const struct nlattr *attr,
6501                             struct nft_object *obj)
6502 {
6503         struct nft_object *newobj;
6504         struct nft_trans *trans;
6505         int err;
6506
6507         trans = nft_trans_alloc(ctx, NFT_MSG_NEWOBJ,
6508                                 sizeof(struct nft_trans_obj));
6509         if (!trans)
6510                 return -ENOMEM;
6511
6512         newobj = nft_obj_init(ctx, type, attr);
6513         if (IS_ERR(newobj)) {
6514                 err = PTR_ERR(newobj);
6515                 goto err_free_trans;
6516         }
6517
6518         nft_trans_obj(trans) = obj;
6519         nft_trans_obj_update(trans) = true;
6520         nft_trans_obj_newobj(trans) = newobj;
6521         nft_trans_commit_list_add_tail(ctx->net, trans);
6522
6523         return 0;
6524
6525 err_free_trans:
6526         kfree(trans);
6527         return err;
6528 }
6529
6530 static int nf_tables_newobj(struct sk_buff *skb, const struct nfnl_info *info,
6531                             const struct nlattr * const nla[])
6532 {
6533         struct netlink_ext_ack *extack = info->extack;
6534         u8 genmask = nft_genmask_next(info->net);
6535         u8 family = info->nfmsg->nfgen_family;
6536         const struct nft_object_type *type;
6537         struct net *net = info->net;
6538         struct nft_table *table;
6539         struct nft_object *obj;
6540         struct nft_ctx ctx;
6541         u32 objtype;
6542         int err;
6543
6544         if (!nla[NFTA_OBJ_TYPE] ||
6545             !nla[NFTA_OBJ_NAME] ||
6546             !nla[NFTA_OBJ_DATA])
6547                 return -EINVAL;
6548
6549         table = nft_table_lookup(net, nla[NFTA_OBJ_TABLE], family, genmask,
6550                                  NETLINK_CB(skb).portid);
6551         if (IS_ERR(table)) {
6552                 NL_SET_BAD_ATTR(extack, nla[NFTA_OBJ_TABLE]);
6553                 return PTR_ERR(table);
6554         }
6555
6556         objtype = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE]));
6557         obj = nft_obj_lookup(net, table, nla[NFTA_OBJ_NAME], objtype, genmask);
6558         if (IS_ERR(obj)) {
6559                 err = PTR_ERR(obj);
6560                 if (err != -ENOENT) {
6561                         NL_SET_BAD_ATTR(extack, nla[NFTA_OBJ_NAME]);
6562                         return err;
6563                 }
6564         } else {
6565                 if (info->nlh->nlmsg_flags & NLM_F_EXCL) {
6566                         NL_SET_BAD_ATTR(extack, nla[NFTA_OBJ_NAME]);
6567                         return -EEXIST;
6568                 }
6569                 if (info->nlh->nlmsg_flags & NLM_F_REPLACE)
6570                         return -EOPNOTSUPP;
6571
6572                 type = __nft_obj_type_get(objtype);
6573                 nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
6574
6575                 return nf_tables_updobj(&ctx, type, nla[NFTA_OBJ_DATA], obj);
6576         }
6577
6578         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
6579
6580         type = nft_obj_type_get(net, objtype);
6581         if (IS_ERR(type))
6582                 return PTR_ERR(type);
6583
6584         obj = nft_obj_init(&ctx, type, nla[NFTA_OBJ_DATA]);
6585         if (IS_ERR(obj)) {
6586                 err = PTR_ERR(obj);
6587                 goto err_init;
6588         }
6589         obj->key.table = table;
6590         obj->handle = nf_tables_alloc_handle(table);
6591
6592         obj->key.name = nla_strdup(nla[NFTA_OBJ_NAME], GFP_KERNEL);
6593         if (!obj->key.name) {
6594                 err = -ENOMEM;
6595                 goto err_strdup;
6596         }
6597
6598         if (nla[NFTA_OBJ_USERDATA]) {
6599                 obj->udata = nla_memdup(nla[NFTA_OBJ_USERDATA], GFP_KERNEL);
6600                 if (obj->udata == NULL)
6601                         goto err_userdata;
6602
6603                 obj->udlen = nla_len(nla[NFTA_OBJ_USERDATA]);
6604         }
6605
6606         err = nft_trans_obj_add(&ctx, NFT_MSG_NEWOBJ, obj);
6607         if (err < 0)
6608                 goto err_trans;
6609
6610         err = rhltable_insert(&nft_objname_ht, &obj->rhlhead,
6611                               nft_objname_ht_params);
6612         if (err < 0)
6613                 goto err_obj_ht;
6614
6615         list_add_tail_rcu(&obj->list, &table->objects);
6616         table->use++;
6617         return 0;
6618 err_obj_ht:
6619         /* queued in transaction log */
6620         INIT_LIST_HEAD(&obj->list);
6621         return err;
6622 err_trans:
6623         kfree(obj->udata);
6624 err_userdata:
6625         kfree(obj->key.name);
6626 err_strdup:
6627         if (obj->ops->destroy)
6628                 obj->ops->destroy(&ctx, obj);
6629         kfree(obj);
6630 err_init:
6631         module_put(type->owner);
6632         return err;
6633 }
6634
6635 static int nf_tables_fill_obj_info(struct sk_buff *skb, struct net *net,
6636                                    u32 portid, u32 seq, int event, u32 flags,
6637                                    int family, const struct nft_table *table,
6638                                    struct nft_object *obj, bool reset)
6639 {
6640         struct nlmsghdr *nlh;
6641
6642         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
6643         nlh = nfnl_msg_put(skb, portid, seq, event, flags, family,
6644                            NFNETLINK_V0, nft_base_seq(net));
6645         if (!nlh)
6646                 goto nla_put_failure;
6647
6648         if (nla_put_string(skb, NFTA_OBJ_TABLE, table->name) ||
6649             nla_put_string(skb, NFTA_OBJ_NAME, obj->key.name) ||
6650             nla_put_be32(skb, NFTA_OBJ_TYPE, htonl(obj->ops->type->type)) ||
6651             nla_put_be32(skb, NFTA_OBJ_USE, htonl(obj->use)) ||
6652             nft_object_dump(skb, NFTA_OBJ_DATA, obj, reset) ||
6653             nla_put_be64(skb, NFTA_OBJ_HANDLE, cpu_to_be64(obj->handle),
6654                          NFTA_OBJ_PAD))
6655                 goto nla_put_failure;
6656
6657         if (obj->udata &&
6658             nla_put(skb, NFTA_OBJ_USERDATA, obj->udlen, obj->udata))
6659                 goto nla_put_failure;
6660
6661         nlmsg_end(skb, nlh);
6662         return 0;
6663
6664 nla_put_failure:
6665         nlmsg_trim(skb, nlh);
6666         return -1;
6667 }
6668
6669 struct nft_obj_filter {
6670         char            *table;
6671         u32             type;
6672 };
6673
6674 static int nf_tables_dump_obj(struct sk_buff *skb, struct netlink_callback *cb)
6675 {
6676         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
6677         const struct nft_table *table;
6678         unsigned int idx = 0, s_idx = cb->args[0];
6679         struct nft_obj_filter *filter = cb->data;
6680         struct net *net = sock_net(skb->sk);
6681         int family = nfmsg->nfgen_family;
6682         struct nftables_pernet *nft_net;
6683         struct nft_object *obj;
6684         bool reset = false;
6685
6686         if (NFNL_MSG_TYPE(cb->nlh->nlmsg_type) == NFT_MSG_GETOBJ_RESET)
6687                 reset = true;
6688
6689         rcu_read_lock();
6690         nft_net = nft_pernet(net);
6691         cb->seq = nft_net->base_seq;
6692
6693         list_for_each_entry_rcu(table, &nft_net->tables, list) {
6694                 if (family != NFPROTO_UNSPEC && family != table->family)
6695                         continue;
6696
6697                 list_for_each_entry_rcu(obj, &table->objects, list) {
6698                         if (!nft_is_active(net, obj))
6699                                 goto cont;
6700                         if (idx < s_idx)
6701                                 goto cont;
6702                         if (idx > s_idx)
6703                                 memset(&cb->args[1], 0,
6704                                        sizeof(cb->args) - sizeof(cb->args[0]));
6705                         if (filter && filter->table &&
6706                             strcmp(filter->table, table->name))
6707                                 goto cont;
6708                         if (filter &&
6709                             filter->type != NFT_OBJECT_UNSPEC &&
6710                             obj->ops->type->type != filter->type)
6711                                 goto cont;
6712                         if (reset) {
6713                                 char *buf = kasprintf(GFP_ATOMIC,
6714                                                       "%s:%u",
6715                                                       table->name,
6716                                                       nft_net->base_seq);
6717
6718                                 audit_log_nfcfg(buf,
6719                                                 family,
6720                                                 obj->handle,
6721                                                 AUDIT_NFT_OP_OBJ_RESET,
6722                                                 GFP_ATOMIC);
6723                                 kfree(buf);
6724                         }
6725
6726                         if (nf_tables_fill_obj_info(skb, net, NETLINK_CB(cb->skb).portid,
6727                                                     cb->nlh->nlmsg_seq,
6728                                                     NFT_MSG_NEWOBJ,
6729                                                     NLM_F_MULTI | NLM_F_APPEND,
6730                                                     table->family, table,
6731                                                     obj, reset) < 0)
6732                                 goto done;
6733
6734                         nl_dump_check_consistent(cb, nlmsg_hdr(skb));
6735 cont:
6736                         idx++;
6737                 }
6738         }
6739 done:
6740         rcu_read_unlock();
6741
6742         cb->args[0] = idx;
6743         return skb->len;
6744 }
6745
6746 static int nf_tables_dump_obj_start(struct netlink_callback *cb)
6747 {
6748         const struct nlattr * const *nla = cb->data;
6749         struct nft_obj_filter *filter = NULL;
6750
6751         if (nla[NFTA_OBJ_TABLE] || nla[NFTA_OBJ_TYPE]) {
6752                 filter = kzalloc(sizeof(*filter), GFP_ATOMIC);
6753                 if (!filter)
6754                         return -ENOMEM;
6755
6756                 if (nla[NFTA_OBJ_TABLE]) {
6757                         filter->table = nla_strdup(nla[NFTA_OBJ_TABLE], GFP_ATOMIC);
6758                         if (!filter->table) {
6759                                 kfree(filter);
6760                                 return -ENOMEM;
6761                         }
6762                 }
6763
6764                 if (nla[NFTA_OBJ_TYPE])
6765                         filter->type = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE]));
6766         }
6767
6768         cb->data = filter;
6769         return 0;
6770 }
6771
6772 static int nf_tables_dump_obj_done(struct netlink_callback *cb)
6773 {
6774         struct nft_obj_filter *filter = cb->data;
6775
6776         if (filter) {
6777                 kfree(filter->table);
6778                 kfree(filter);
6779         }
6780
6781         return 0;
6782 }
6783
6784 /* called with rcu_read_lock held */
6785 static int nf_tables_getobj(struct sk_buff *skb, const struct nfnl_info *info,
6786                             const struct nlattr * const nla[])
6787 {
6788         struct netlink_ext_ack *extack = info->extack;
6789         u8 genmask = nft_genmask_cur(info->net);
6790         u8 family = info->nfmsg->nfgen_family;
6791         const struct nft_table *table;
6792         struct net *net = info->net;
6793         struct nft_object *obj;
6794         struct sk_buff *skb2;
6795         bool reset = false;
6796         u32 objtype;
6797         int err;
6798
6799         if (info->nlh->nlmsg_flags & NLM_F_DUMP) {
6800                 struct netlink_dump_control c = {
6801                         .start = nf_tables_dump_obj_start,
6802                         .dump = nf_tables_dump_obj,
6803                         .done = nf_tables_dump_obj_done,
6804                         .module = THIS_MODULE,
6805                         .data = (void *)nla,
6806                 };
6807
6808                 return nft_netlink_dump_start_rcu(info->sk, skb, info->nlh, &c);
6809         }
6810
6811         if (!nla[NFTA_OBJ_NAME] ||
6812             !nla[NFTA_OBJ_TYPE])
6813                 return -EINVAL;
6814
6815         table = nft_table_lookup(net, nla[NFTA_OBJ_TABLE], family, genmask, 0);
6816         if (IS_ERR(table)) {
6817                 NL_SET_BAD_ATTR(extack, nla[NFTA_OBJ_TABLE]);
6818                 return PTR_ERR(table);
6819         }
6820
6821         objtype = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE]));
6822         obj = nft_obj_lookup(net, table, nla[NFTA_OBJ_NAME], objtype, genmask);
6823         if (IS_ERR(obj)) {
6824                 NL_SET_BAD_ATTR(extack, nla[NFTA_OBJ_NAME]);
6825                 return PTR_ERR(obj);
6826         }
6827
6828         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
6829         if (!skb2)
6830                 return -ENOMEM;
6831
6832         if (NFNL_MSG_TYPE(info->nlh->nlmsg_type) == NFT_MSG_GETOBJ_RESET)
6833                 reset = true;
6834
6835         if (reset) {
6836                 const struct nftables_pernet *nft_net;
6837                 char *buf;
6838
6839                 nft_net = nft_pernet(net);
6840                 buf = kasprintf(GFP_ATOMIC, "%s:%u", table->name, nft_net->base_seq);
6841
6842                 audit_log_nfcfg(buf,
6843                                 family,
6844                                 obj->handle,
6845                                 AUDIT_NFT_OP_OBJ_RESET,
6846                                 GFP_ATOMIC);
6847                 kfree(buf);
6848         }
6849
6850         err = nf_tables_fill_obj_info(skb2, net, NETLINK_CB(skb).portid,
6851                                       info->nlh->nlmsg_seq, NFT_MSG_NEWOBJ, 0,
6852                                       family, table, obj, reset);
6853         if (err < 0)
6854                 goto err_fill_obj_info;
6855
6856         return nfnetlink_unicast(skb2, net, NETLINK_CB(skb).portid);
6857
6858 err_fill_obj_info:
6859         kfree_skb(skb2);
6860         return err;
6861 }
6862
6863 static void nft_obj_destroy(const struct nft_ctx *ctx, struct nft_object *obj)
6864 {
6865         if (obj->ops->destroy)
6866                 obj->ops->destroy(ctx, obj);
6867
6868         module_put(obj->ops->type->owner);
6869         kfree(obj->key.name);
6870         kfree(obj->udata);
6871         kfree(obj);
6872 }
6873
6874 static int nf_tables_delobj(struct sk_buff *skb, const struct nfnl_info *info,
6875                             const struct nlattr * const nla[])
6876 {
6877         struct netlink_ext_ack *extack = info->extack;
6878         u8 genmask = nft_genmask_next(info->net);
6879         u8 family = info->nfmsg->nfgen_family;
6880         struct net *net = info->net;
6881         const struct nlattr *attr;
6882         struct nft_table *table;
6883         struct nft_object *obj;
6884         struct nft_ctx ctx;
6885         u32 objtype;
6886
6887         if (!nla[NFTA_OBJ_TYPE] ||
6888             (!nla[NFTA_OBJ_NAME] && !nla[NFTA_OBJ_HANDLE]))
6889                 return -EINVAL;
6890
6891         table = nft_table_lookup(net, nla[NFTA_OBJ_TABLE], family, genmask,
6892                                  NETLINK_CB(skb).portid);
6893         if (IS_ERR(table)) {
6894                 NL_SET_BAD_ATTR(extack, nla[NFTA_OBJ_TABLE]);
6895                 return PTR_ERR(table);
6896         }
6897
6898         objtype = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE]));
6899         if (nla[NFTA_OBJ_HANDLE]) {
6900                 attr = nla[NFTA_OBJ_HANDLE];
6901                 obj = nft_obj_lookup_byhandle(table, attr, objtype, genmask);
6902         } else {
6903                 attr = nla[NFTA_OBJ_NAME];
6904                 obj = nft_obj_lookup(net, table, attr, objtype, genmask);
6905         }
6906
6907         if (IS_ERR(obj)) {
6908                 NL_SET_BAD_ATTR(extack, attr);
6909                 return PTR_ERR(obj);
6910         }
6911         if (obj->use > 0) {
6912                 NL_SET_BAD_ATTR(extack, attr);
6913                 return -EBUSY;
6914         }
6915
6916         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
6917
6918         return nft_delobj(&ctx, obj);
6919 }
6920
6921 void nft_obj_notify(struct net *net, const struct nft_table *table,
6922                     struct nft_object *obj, u32 portid, u32 seq, int event,
6923                     int family, int report, gfp_t gfp)
6924 {
6925         struct nftables_pernet *nft_net = nft_pernet(net);
6926         struct sk_buff *skb;
6927         int err;
6928         char *buf = kasprintf(gfp, "%s:%u",
6929                               table->name, nft_net->base_seq);
6930
6931         audit_log_nfcfg(buf,
6932                         family,
6933                         obj->handle,
6934                         event == NFT_MSG_NEWOBJ ?
6935                                  AUDIT_NFT_OP_OBJ_REGISTER :
6936                                  AUDIT_NFT_OP_OBJ_UNREGISTER,
6937                         gfp);
6938         kfree(buf);
6939
6940         if (!report &&
6941             !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
6942                 return;
6943
6944         skb = nlmsg_new(NLMSG_GOODSIZE, gfp);
6945         if (skb == NULL)
6946                 goto err;
6947
6948         err = nf_tables_fill_obj_info(skb, net, portid, seq, event, 0, family,
6949                                       table, obj, false);
6950         if (err < 0) {
6951                 kfree_skb(skb);
6952                 goto err;
6953         }
6954
6955         nft_notify_enqueue(skb, report, &nft_net->notify_list);
6956         return;
6957 err:
6958         nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
6959 }
6960 EXPORT_SYMBOL_GPL(nft_obj_notify);
6961
6962 static void nf_tables_obj_notify(const struct nft_ctx *ctx,
6963                                  struct nft_object *obj, int event)
6964 {
6965         nft_obj_notify(ctx->net, ctx->table, obj, ctx->portid, ctx->seq, event,
6966                        ctx->family, ctx->report, GFP_KERNEL);
6967 }
6968
6969 /*
6970  * Flow tables
6971  */
6972 void nft_register_flowtable_type(struct nf_flowtable_type *type)
6973 {
6974         nfnl_lock(NFNL_SUBSYS_NFTABLES);
6975         list_add_tail_rcu(&type->list, &nf_tables_flowtables);
6976         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
6977 }
6978 EXPORT_SYMBOL_GPL(nft_register_flowtable_type);
6979
6980 void nft_unregister_flowtable_type(struct nf_flowtable_type *type)
6981 {
6982         nfnl_lock(NFNL_SUBSYS_NFTABLES);
6983         list_del_rcu(&type->list);
6984         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
6985 }
6986 EXPORT_SYMBOL_GPL(nft_unregister_flowtable_type);
6987
6988 static const struct nla_policy nft_flowtable_policy[NFTA_FLOWTABLE_MAX + 1] = {
6989         [NFTA_FLOWTABLE_TABLE]          = { .type = NLA_STRING,
6990                                             .len = NFT_NAME_MAXLEN - 1 },
6991         [NFTA_FLOWTABLE_NAME]           = { .type = NLA_STRING,
6992                                             .len = NFT_NAME_MAXLEN - 1 },
6993         [NFTA_FLOWTABLE_HOOK]           = { .type = NLA_NESTED },
6994         [NFTA_FLOWTABLE_HANDLE]         = { .type = NLA_U64 },
6995         [NFTA_FLOWTABLE_FLAGS]          = { .type = NLA_U32 },
6996 };
6997
6998 struct nft_flowtable *nft_flowtable_lookup(const struct nft_table *table,
6999                                            const struct nlattr *nla, u8 genmask)
7000 {
7001         struct nft_flowtable *flowtable;
7002
7003         list_for_each_entry_rcu(flowtable, &table->flowtables, list) {
7004                 if (!nla_strcmp(nla, flowtable->name) &&
7005                     nft_active_genmask(flowtable, genmask))
7006                         return flowtable;
7007         }
7008         return ERR_PTR(-ENOENT);
7009 }
7010 EXPORT_SYMBOL_GPL(nft_flowtable_lookup);
7011
7012 void nf_tables_deactivate_flowtable(const struct nft_ctx *ctx,
7013                                     struct nft_flowtable *flowtable,
7014                                     enum nft_trans_phase phase)
7015 {
7016         switch (phase) {
7017         case NFT_TRANS_PREPARE:
7018         case NFT_TRANS_ABORT:
7019         case NFT_TRANS_RELEASE:
7020                 flowtable->use--;
7021                 fallthrough;
7022         default:
7023                 return;
7024         }
7025 }
7026 EXPORT_SYMBOL_GPL(nf_tables_deactivate_flowtable);
7027
7028 static struct nft_flowtable *
7029 nft_flowtable_lookup_byhandle(const struct nft_table *table,
7030                               const struct nlattr *nla, u8 genmask)
7031 {
7032        struct nft_flowtable *flowtable;
7033
7034        list_for_each_entry(flowtable, &table->flowtables, list) {
7035                if (be64_to_cpu(nla_get_be64(nla)) == flowtable->handle &&
7036                    nft_active_genmask(flowtable, genmask))
7037                        return flowtable;
7038        }
7039        return ERR_PTR(-ENOENT);
7040 }
7041
7042 struct nft_flowtable_hook {
7043         u32                     num;
7044         int                     priority;
7045         struct list_head        list;
7046 };
7047
7048 static const struct nla_policy nft_flowtable_hook_policy[NFTA_FLOWTABLE_HOOK_MAX + 1] = {
7049         [NFTA_FLOWTABLE_HOOK_NUM]       = { .type = NLA_U32 },
7050         [NFTA_FLOWTABLE_HOOK_PRIORITY]  = { .type = NLA_U32 },
7051         [NFTA_FLOWTABLE_HOOK_DEVS]      = { .type = NLA_NESTED },
7052 };
7053
7054 static int nft_flowtable_parse_hook(const struct nft_ctx *ctx,
7055                                     const struct nlattr *attr,
7056                                     struct nft_flowtable_hook *flowtable_hook,
7057                                     struct nft_flowtable *flowtable, bool add)
7058 {
7059         struct nlattr *tb[NFTA_FLOWTABLE_HOOK_MAX + 1];
7060         struct nft_hook *hook;
7061         int hooknum, priority;
7062         int err;
7063
7064         INIT_LIST_HEAD(&flowtable_hook->list);
7065
7066         err = nla_parse_nested_deprecated(tb, NFTA_FLOWTABLE_HOOK_MAX, attr,
7067                                           nft_flowtable_hook_policy, NULL);
7068         if (err < 0)
7069                 return err;
7070
7071         if (add) {
7072                 if (!tb[NFTA_FLOWTABLE_HOOK_NUM] ||
7073                     !tb[NFTA_FLOWTABLE_HOOK_PRIORITY])
7074                         return -EINVAL;
7075
7076                 hooknum = ntohl(nla_get_be32(tb[NFTA_FLOWTABLE_HOOK_NUM]));
7077                 if (hooknum != NF_NETDEV_INGRESS)
7078                         return -EOPNOTSUPP;
7079
7080                 priority = ntohl(nla_get_be32(tb[NFTA_FLOWTABLE_HOOK_PRIORITY]));
7081
7082                 flowtable_hook->priority        = priority;
7083                 flowtable_hook->num             = hooknum;
7084         } else {
7085                 if (tb[NFTA_FLOWTABLE_HOOK_NUM]) {
7086                         hooknum = ntohl(nla_get_be32(tb[NFTA_FLOWTABLE_HOOK_NUM]));
7087                         if (hooknum != flowtable->hooknum)
7088                                 return -EOPNOTSUPP;
7089                 }
7090
7091                 if (tb[NFTA_FLOWTABLE_HOOK_PRIORITY]) {
7092                         priority = ntohl(nla_get_be32(tb[NFTA_FLOWTABLE_HOOK_PRIORITY]));
7093                         if (priority != flowtable->data.priority)
7094                                 return -EOPNOTSUPP;
7095                 }
7096
7097                 flowtable_hook->priority        = flowtable->data.priority;
7098                 flowtable_hook->num             = flowtable->hooknum;
7099         }
7100
7101         if (tb[NFTA_FLOWTABLE_HOOK_DEVS]) {
7102                 err = nf_tables_parse_netdev_hooks(ctx->net,
7103                                                    tb[NFTA_FLOWTABLE_HOOK_DEVS],
7104                                                    &flowtable_hook->list);
7105                 if (err < 0)
7106                         return err;
7107         }
7108
7109         list_for_each_entry(hook, &flowtable_hook->list, list) {
7110                 hook->ops.pf            = NFPROTO_NETDEV;
7111                 hook->ops.hooknum       = flowtable_hook->num;
7112                 hook->ops.priority      = flowtable_hook->priority;
7113                 hook->ops.priv          = &flowtable->data;
7114                 hook->ops.hook          = flowtable->data.type->hook;
7115         }
7116
7117         return err;
7118 }
7119
7120 static const struct nf_flowtable_type *__nft_flowtable_type_get(u8 family)
7121 {
7122         const struct nf_flowtable_type *type;
7123
7124         list_for_each_entry(type, &nf_tables_flowtables, list) {
7125                 if (family == type->family)
7126                         return type;
7127         }
7128         return NULL;
7129 }
7130
7131 static const struct nf_flowtable_type *
7132 nft_flowtable_type_get(struct net *net, u8 family)
7133 {
7134         const struct nf_flowtable_type *type;
7135
7136         type = __nft_flowtable_type_get(family);
7137         if (type != NULL && try_module_get(type->owner))
7138                 return type;
7139
7140         lockdep_nfnl_nft_mutex_not_held();
7141 #ifdef CONFIG_MODULES
7142         if (type == NULL) {
7143                 if (nft_request_module(net, "nf-flowtable-%u", family) == -EAGAIN)
7144                         return ERR_PTR(-EAGAIN);
7145         }
7146 #endif
7147         return ERR_PTR(-ENOENT);
7148 }
7149
7150 /* Only called from error and netdev event paths. */
7151 static void nft_unregister_flowtable_hook(struct net *net,
7152                                           struct nft_flowtable *flowtable,
7153                                           struct nft_hook *hook)
7154 {
7155         nf_unregister_net_hook(net, &hook->ops);
7156         flowtable->data.type->setup(&flowtable->data, hook->ops.dev,
7157                                     FLOW_BLOCK_UNBIND);
7158 }
7159
7160 static void nft_unregister_flowtable_net_hooks(struct net *net,
7161                                                struct list_head *hook_list)
7162 {
7163         struct nft_hook *hook;
7164
7165         list_for_each_entry(hook, hook_list, list)
7166                 nf_unregister_net_hook(net, &hook->ops);
7167 }
7168
7169 static int nft_register_flowtable_net_hooks(struct net *net,
7170                                             struct nft_table *table,
7171                                             struct list_head *hook_list,
7172                                             struct nft_flowtable *flowtable)
7173 {
7174         struct nft_hook *hook, *hook2, *next;
7175         struct nft_flowtable *ft;
7176         int err, i = 0;
7177
7178         list_for_each_entry(hook, hook_list, list) {
7179                 list_for_each_entry(ft, &table->flowtables, list) {
7180                         if (!nft_is_active_next(net, ft))
7181                                 continue;
7182
7183                         list_for_each_entry(hook2, &ft->hook_list, list) {
7184                                 if (hook->ops.dev == hook2->ops.dev &&
7185                                     hook->ops.pf == hook2->ops.pf) {
7186                                         err = -EEXIST;
7187                                         goto err_unregister_net_hooks;
7188                                 }
7189                         }
7190                 }
7191
7192                 err = flowtable->data.type->setup(&flowtable->data,
7193                                                   hook->ops.dev,
7194                                                   FLOW_BLOCK_BIND);
7195                 if (err < 0)
7196                         goto err_unregister_net_hooks;
7197
7198                 err = nf_register_net_hook(net, &hook->ops);
7199                 if (err < 0) {
7200                         flowtable->data.type->setup(&flowtable->data,
7201                                                     hook->ops.dev,
7202                                                     FLOW_BLOCK_UNBIND);
7203                         goto err_unregister_net_hooks;
7204                 }
7205
7206                 i++;
7207         }
7208
7209         return 0;
7210
7211 err_unregister_net_hooks:
7212         list_for_each_entry_safe(hook, next, hook_list, list) {
7213                 if (i-- <= 0)
7214                         break;
7215
7216                 nft_unregister_flowtable_hook(net, flowtable, hook);
7217                 list_del_rcu(&hook->list);
7218                 kfree_rcu(hook, rcu);
7219         }
7220
7221         return err;
7222 }
7223
7224 static void nft_flowtable_hooks_destroy(struct list_head *hook_list)
7225 {
7226         struct nft_hook *hook, *next;
7227
7228         list_for_each_entry_safe(hook, next, hook_list, list) {
7229                 list_del_rcu(&hook->list);
7230                 kfree_rcu(hook, rcu);
7231         }
7232 }
7233
7234 static int nft_flowtable_update(struct nft_ctx *ctx, const struct nlmsghdr *nlh,
7235                                 struct nft_flowtable *flowtable)
7236 {
7237         const struct nlattr * const *nla = ctx->nla;
7238         struct nft_flowtable_hook flowtable_hook;
7239         struct nft_hook *hook, *next;
7240         struct nft_trans *trans;
7241         bool unregister = false;
7242         u32 flags;
7243         int err;
7244
7245         err = nft_flowtable_parse_hook(ctx, nla[NFTA_FLOWTABLE_HOOK],
7246                                        &flowtable_hook, flowtable, false);
7247         if (err < 0)
7248                 return err;
7249
7250         list_for_each_entry_safe(hook, next, &flowtable_hook.list, list) {
7251                 if (nft_hook_list_find(&flowtable->hook_list, hook)) {
7252                         list_del(&hook->list);
7253                         kfree(hook);
7254                 }
7255         }
7256
7257         if (nla[NFTA_FLOWTABLE_FLAGS]) {
7258                 flags = ntohl(nla_get_be32(nla[NFTA_FLOWTABLE_FLAGS]));
7259                 if (flags & ~NFT_FLOWTABLE_MASK)
7260                         return -EOPNOTSUPP;
7261                 if ((flowtable->data.flags & NFT_FLOWTABLE_HW_OFFLOAD) ^
7262                     (flags & NFT_FLOWTABLE_HW_OFFLOAD))
7263                         return -EOPNOTSUPP;
7264         } else {
7265                 flags = flowtable->data.flags;
7266         }
7267
7268         err = nft_register_flowtable_net_hooks(ctx->net, ctx->table,
7269                                                &flowtable_hook.list, flowtable);
7270         if (err < 0)
7271                 goto err_flowtable_update_hook;
7272
7273         trans = nft_trans_alloc(ctx, NFT_MSG_NEWFLOWTABLE,
7274                                 sizeof(struct nft_trans_flowtable));
7275         if (!trans) {
7276                 unregister = true;
7277                 err = -ENOMEM;
7278                 goto err_flowtable_update_hook;
7279         }
7280
7281         nft_trans_flowtable_flags(trans) = flags;
7282         nft_trans_flowtable(trans) = flowtable;
7283         nft_trans_flowtable_update(trans) = true;
7284         INIT_LIST_HEAD(&nft_trans_flowtable_hooks(trans));
7285         list_splice(&flowtable_hook.list, &nft_trans_flowtable_hooks(trans));
7286
7287         nft_trans_commit_list_add_tail(ctx->net, trans);
7288
7289         return 0;
7290
7291 err_flowtable_update_hook:
7292         list_for_each_entry_safe(hook, next, &flowtable_hook.list, list) {
7293                 if (unregister)
7294                         nft_unregister_flowtable_hook(ctx->net, flowtable, hook);
7295                 list_del_rcu(&hook->list);
7296                 kfree_rcu(hook, rcu);
7297         }
7298
7299         return err;
7300
7301 }
7302
7303 static int nf_tables_newflowtable(struct sk_buff *skb,
7304                                   const struct nfnl_info *info,
7305                                   const struct nlattr * const nla[])
7306 {
7307         struct netlink_ext_ack *extack = info->extack;
7308         struct nft_flowtable_hook flowtable_hook;
7309         u8 genmask = nft_genmask_next(info->net);
7310         u8 family = info->nfmsg->nfgen_family;
7311         const struct nf_flowtable_type *type;
7312         struct nft_flowtable *flowtable;
7313         struct nft_hook *hook, *next;
7314         struct net *net = info->net;
7315         struct nft_table *table;
7316         struct nft_ctx ctx;
7317         int err;
7318
7319         if (!nla[NFTA_FLOWTABLE_TABLE] ||
7320             !nla[NFTA_FLOWTABLE_NAME] ||
7321             !nla[NFTA_FLOWTABLE_HOOK])
7322                 return -EINVAL;
7323
7324         table = nft_table_lookup(net, nla[NFTA_FLOWTABLE_TABLE], family,
7325                                  genmask, NETLINK_CB(skb).portid);
7326         if (IS_ERR(table)) {
7327                 NL_SET_BAD_ATTR(extack, nla[NFTA_FLOWTABLE_TABLE]);
7328                 return PTR_ERR(table);
7329         }
7330
7331         flowtable = nft_flowtable_lookup(table, nla[NFTA_FLOWTABLE_NAME],
7332                                          genmask);
7333         if (IS_ERR(flowtable)) {
7334                 err = PTR_ERR(flowtable);
7335                 if (err != -ENOENT) {
7336                         NL_SET_BAD_ATTR(extack, nla[NFTA_FLOWTABLE_NAME]);
7337                         return err;
7338                 }
7339         } else {
7340                 if (info->nlh->nlmsg_flags & NLM_F_EXCL) {
7341                         NL_SET_BAD_ATTR(extack, nla[NFTA_FLOWTABLE_NAME]);
7342                         return -EEXIST;
7343                 }
7344
7345                 nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
7346
7347                 return nft_flowtable_update(&ctx, info->nlh, flowtable);
7348         }
7349
7350         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
7351
7352         flowtable = kzalloc(sizeof(*flowtable), GFP_KERNEL);
7353         if (!flowtable)
7354                 return -ENOMEM;
7355
7356         flowtable->table = table;
7357         flowtable->handle = nf_tables_alloc_handle(table);
7358         INIT_LIST_HEAD(&flowtable->hook_list);
7359
7360         flowtable->name = nla_strdup(nla[NFTA_FLOWTABLE_NAME], GFP_KERNEL);
7361         if (!flowtable->name) {
7362                 err = -ENOMEM;
7363                 goto err1;
7364         }
7365
7366         type = nft_flowtable_type_get(net, family);
7367         if (IS_ERR(type)) {
7368                 err = PTR_ERR(type);
7369                 goto err2;
7370         }
7371
7372         if (nla[NFTA_FLOWTABLE_FLAGS]) {
7373                 flowtable->data.flags =
7374                         ntohl(nla_get_be32(nla[NFTA_FLOWTABLE_FLAGS]));
7375                 if (flowtable->data.flags & ~NFT_FLOWTABLE_MASK) {
7376                         err = -EOPNOTSUPP;
7377                         goto err3;
7378                 }
7379         }
7380
7381         write_pnet(&flowtable->data.net, net);
7382         flowtable->data.type = type;
7383         err = type->init(&flowtable->data);
7384         if (err < 0)
7385                 goto err3;
7386
7387         err = nft_flowtable_parse_hook(&ctx, nla[NFTA_FLOWTABLE_HOOK],
7388                                        &flowtable_hook, flowtable, true);
7389         if (err < 0)
7390                 goto err4;
7391
7392         list_splice(&flowtable_hook.list, &flowtable->hook_list);
7393         flowtable->data.priority = flowtable_hook.priority;
7394         flowtable->hooknum = flowtable_hook.num;
7395
7396         err = nft_register_flowtable_net_hooks(ctx.net, table,
7397                                                &flowtable->hook_list,
7398                                                flowtable);
7399         if (err < 0) {
7400                 nft_flowtable_hooks_destroy(&flowtable->hook_list);
7401                 goto err4;
7402         }
7403
7404         err = nft_trans_flowtable_add(&ctx, NFT_MSG_NEWFLOWTABLE, flowtable);
7405         if (err < 0)
7406                 goto err5;
7407
7408         list_add_tail_rcu(&flowtable->list, &table->flowtables);
7409         table->use++;
7410
7411         return 0;
7412 err5:
7413         list_for_each_entry_safe(hook, next, &flowtable->hook_list, list) {
7414                 nft_unregister_flowtable_hook(net, flowtable, hook);
7415                 list_del_rcu(&hook->list);
7416                 kfree_rcu(hook, rcu);
7417         }
7418 err4:
7419         flowtable->data.type->free(&flowtable->data);
7420 err3:
7421         module_put(type->owner);
7422 err2:
7423         kfree(flowtable->name);
7424 err1:
7425         kfree(flowtable);
7426         return err;
7427 }
7428
7429 static void nft_flowtable_hook_release(struct nft_flowtable_hook *flowtable_hook)
7430 {
7431         struct nft_hook *this, *next;
7432
7433         list_for_each_entry_safe(this, next, &flowtable_hook->list, list) {
7434                 list_del(&this->list);
7435                 kfree(this);
7436         }
7437 }
7438
7439 static int nft_delflowtable_hook(struct nft_ctx *ctx,
7440                                  struct nft_flowtable *flowtable)
7441 {
7442         const struct nlattr * const *nla = ctx->nla;
7443         struct nft_flowtable_hook flowtable_hook;
7444         struct nft_hook *this, *hook;
7445         struct nft_trans *trans;
7446         int err;
7447
7448         err = nft_flowtable_parse_hook(ctx, nla[NFTA_FLOWTABLE_HOOK],
7449                                        &flowtable_hook, flowtable, false);
7450         if (err < 0)
7451                 return err;
7452
7453         list_for_each_entry(this, &flowtable_hook.list, list) {
7454                 hook = nft_hook_list_find(&flowtable->hook_list, this);
7455                 if (!hook) {
7456                         err = -ENOENT;
7457                         goto err_flowtable_del_hook;
7458                 }
7459                 hook->inactive = true;
7460         }
7461
7462         trans = nft_trans_alloc(ctx, NFT_MSG_DELFLOWTABLE,
7463                                 sizeof(struct nft_trans_flowtable));
7464         if (!trans) {
7465                 err = -ENOMEM;
7466                 goto err_flowtable_del_hook;
7467         }
7468
7469         nft_trans_flowtable(trans) = flowtable;
7470         nft_trans_flowtable_update(trans) = true;
7471         INIT_LIST_HEAD(&nft_trans_flowtable_hooks(trans));
7472         nft_flowtable_hook_release(&flowtable_hook);
7473
7474         nft_trans_commit_list_add_tail(ctx->net, trans);
7475
7476         return 0;
7477
7478 err_flowtable_del_hook:
7479         list_for_each_entry(this, &flowtable_hook.list, list) {
7480                 hook = nft_hook_list_find(&flowtable->hook_list, this);
7481                 if (!hook)
7482                         break;
7483
7484                 hook->inactive = false;
7485         }
7486         nft_flowtable_hook_release(&flowtable_hook);
7487
7488         return err;
7489 }
7490
7491 static int nf_tables_delflowtable(struct sk_buff *skb,
7492                                   const struct nfnl_info *info,
7493                                   const struct nlattr * const nla[])
7494 {
7495         struct netlink_ext_ack *extack = info->extack;
7496         u8 genmask = nft_genmask_next(info->net);
7497         u8 family = info->nfmsg->nfgen_family;
7498         struct nft_flowtable *flowtable;
7499         struct net *net = info->net;
7500         const struct nlattr *attr;
7501         struct nft_table *table;
7502         struct nft_ctx ctx;
7503
7504         if (!nla[NFTA_FLOWTABLE_TABLE] ||
7505             (!nla[NFTA_FLOWTABLE_NAME] &&
7506              !nla[NFTA_FLOWTABLE_HANDLE]))
7507                 return -EINVAL;
7508
7509         table = nft_table_lookup(net, nla[NFTA_FLOWTABLE_TABLE], family,
7510                                  genmask, NETLINK_CB(skb).portid);
7511         if (IS_ERR(table)) {
7512                 NL_SET_BAD_ATTR(extack, nla[NFTA_FLOWTABLE_TABLE]);
7513                 return PTR_ERR(table);
7514         }
7515
7516         if (nla[NFTA_FLOWTABLE_HANDLE]) {
7517                 attr = nla[NFTA_FLOWTABLE_HANDLE];
7518                 flowtable = nft_flowtable_lookup_byhandle(table, attr, genmask);
7519         } else {
7520                 attr = nla[NFTA_FLOWTABLE_NAME];
7521                 flowtable = nft_flowtable_lookup(table, attr, genmask);
7522         }
7523
7524         if (IS_ERR(flowtable)) {
7525                 NL_SET_BAD_ATTR(extack, attr);
7526                 return PTR_ERR(flowtable);
7527         }
7528
7529         nft_ctx_init(&ctx, net, skb, info->nlh, family, table, NULL, nla);
7530
7531         if (nla[NFTA_FLOWTABLE_HOOK])
7532                 return nft_delflowtable_hook(&ctx, flowtable);
7533
7534         if (flowtable->use > 0) {
7535                 NL_SET_BAD_ATTR(extack, attr);
7536                 return -EBUSY;
7537         }
7538
7539         return nft_delflowtable(&ctx, flowtable);
7540 }
7541
7542 static int nf_tables_fill_flowtable_info(struct sk_buff *skb, struct net *net,
7543                                          u32 portid, u32 seq, int event,
7544                                          u32 flags, int family,
7545                                          struct nft_flowtable *flowtable,
7546                                          struct list_head *hook_list)
7547 {
7548         struct nlattr *nest, *nest_devs;
7549         struct nft_hook *hook;
7550         struct nlmsghdr *nlh;
7551
7552         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
7553         nlh = nfnl_msg_put(skb, portid, seq, event, flags, family,
7554                            NFNETLINK_V0, nft_base_seq(net));
7555         if (!nlh)
7556                 goto nla_put_failure;
7557
7558         if (nla_put_string(skb, NFTA_FLOWTABLE_TABLE, flowtable->table->name) ||
7559             nla_put_string(skb, NFTA_FLOWTABLE_NAME, flowtable->name) ||
7560             nla_put_be32(skb, NFTA_FLOWTABLE_USE, htonl(flowtable->use)) ||
7561             nla_put_be64(skb, NFTA_FLOWTABLE_HANDLE, cpu_to_be64(flowtable->handle),
7562                          NFTA_FLOWTABLE_PAD) ||
7563             nla_put_be32(skb, NFTA_FLOWTABLE_FLAGS, htonl(flowtable->data.flags)))
7564                 goto nla_put_failure;
7565
7566         nest = nla_nest_start_noflag(skb, NFTA_FLOWTABLE_HOOK);
7567         if (!nest)
7568                 goto nla_put_failure;
7569         if (nla_put_be32(skb, NFTA_FLOWTABLE_HOOK_NUM, htonl(flowtable->hooknum)) ||
7570             nla_put_be32(skb, NFTA_FLOWTABLE_HOOK_PRIORITY, htonl(flowtable->data.priority)))
7571                 goto nla_put_failure;
7572
7573         nest_devs = nla_nest_start_noflag(skb, NFTA_FLOWTABLE_HOOK_DEVS);
7574         if (!nest_devs)
7575                 goto nla_put_failure;
7576
7577         list_for_each_entry_rcu(hook, hook_list, list) {
7578                 if (nla_put_string(skb, NFTA_DEVICE_NAME, hook->ops.dev->name))
7579                         goto nla_put_failure;
7580         }
7581         nla_nest_end(skb, nest_devs);
7582         nla_nest_end(skb, nest);
7583
7584         nlmsg_end(skb, nlh);
7585         return 0;
7586
7587 nla_put_failure:
7588         nlmsg_trim(skb, nlh);
7589         return -1;
7590 }
7591
7592 struct nft_flowtable_filter {
7593         char            *table;
7594 };
7595
7596 static int nf_tables_dump_flowtable(struct sk_buff *skb,
7597                                     struct netlink_callback *cb)
7598 {
7599         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
7600         struct nft_flowtable_filter *filter = cb->data;
7601         unsigned int idx = 0, s_idx = cb->args[0];
7602         struct net *net = sock_net(skb->sk);
7603         int family = nfmsg->nfgen_family;
7604         struct nft_flowtable *flowtable;
7605         struct nftables_pernet *nft_net;
7606         const struct nft_table *table;
7607
7608         rcu_read_lock();
7609         nft_net = nft_pernet(net);
7610         cb->seq = nft_net->base_seq;
7611
7612         list_for_each_entry_rcu(table, &nft_net->tables, list) {
7613                 if (family != NFPROTO_UNSPEC && family != table->family)
7614                         continue;
7615
7616                 list_for_each_entry_rcu(flowtable, &table->flowtables, list) {
7617                         if (!nft_is_active(net, flowtable))
7618                                 goto cont;
7619                         if (idx < s_idx)
7620                                 goto cont;
7621                         if (idx > s_idx)
7622                                 memset(&cb->args[1], 0,
7623                                        sizeof(cb->args) - sizeof(cb->args[0]));
7624                         if (filter && filter->table &&
7625                             strcmp(filter->table, table->name))
7626                                 goto cont;
7627
7628                         if (nf_tables_fill_flowtable_info(skb, net, NETLINK_CB(cb->skb).portid,
7629                                                           cb->nlh->nlmsg_seq,
7630                                                           NFT_MSG_NEWFLOWTABLE,
7631                                                           NLM_F_MULTI | NLM_F_APPEND,
7632                                                           table->family,
7633                                                           flowtable,
7634                                                           &flowtable->hook_list) < 0)
7635                                 goto done;
7636
7637                         nl_dump_check_consistent(cb, nlmsg_hdr(skb));
7638 cont:
7639                         idx++;
7640                 }
7641         }
7642 done:
7643         rcu_read_unlock();
7644
7645         cb->args[0] = idx;
7646         return skb->len;
7647 }
7648
7649 static int nf_tables_dump_flowtable_start(struct netlink_callback *cb)
7650 {
7651         const struct nlattr * const *nla = cb->data;
7652         struct nft_flowtable_filter *filter = NULL;
7653
7654         if (nla[NFTA_FLOWTABLE_TABLE]) {
7655                 filter = kzalloc(sizeof(*filter), GFP_ATOMIC);
7656                 if (!filter)
7657                         return -ENOMEM;
7658
7659                 filter->table = nla_strdup(nla[NFTA_FLOWTABLE_TABLE],
7660                                            GFP_ATOMIC);
7661                 if (!filter->table) {
7662                         kfree(filter);
7663                         return -ENOMEM;
7664                 }
7665         }
7666
7667         cb->data = filter;
7668         return 0;
7669 }
7670
7671 static int nf_tables_dump_flowtable_done(struct netlink_callback *cb)
7672 {
7673         struct nft_flowtable_filter *filter = cb->data;
7674
7675         if (!filter)
7676                 return 0;
7677
7678         kfree(filter->table);
7679         kfree(filter);
7680
7681         return 0;
7682 }
7683
7684 /* called with rcu_read_lock held */
7685 static int nf_tables_getflowtable(struct sk_buff *skb,
7686                                   const struct nfnl_info *info,
7687                                   const struct nlattr * const nla[])
7688 {
7689         u8 genmask = nft_genmask_cur(info->net);
7690         u8 family = info->nfmsg->nfgen_family;
7691         struct nft_flowtable *flowtable;
7692         const struct nft_table *table;
7693         struct net *net = info->net;
7694         struct sk_buff *skb2;
7695         int err;
7696
7697         if (info->nlh->nlmsg_flags & NLM_F_DUMP) {
7698                 struct netlink_dump_control c = {
7699                         .start = nf_tables_dump_flowtable_start,
7700                         .dump = nf_tables_dump_flowtable,
7701                         .done = nf_tables_dump_flowtable_done,
7702                         .module = THIS_MODULE,
7703                         .data = (void *)nla,
7704                 };
7705
7706                 return nft_netlink_dump_start_rcu(info->sk, skb, info->nlh, &c);
7707         }
7708
7709         if (!nla[NFTA_FLOWTABLE_NAME])
7710                 return -EINVAL;
7711
7712         table = nft_table_lookup(net, nla[NFTA_FLOWTABLE_TABLE], family,
7713                                  genmask, 0);
7714         if (IS_ERR(table))
7715                 return PTR_ERR(table);
7716
7717         flowtable = nft_flowtable_lookup(table, nla[NFTA_FLOWTABLE_NAME],
7718                                          genmask);
7719         if (IS_ERR(flowtable))
7720                 return PTR_ERR(flowtable);
7721
7722         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
7723         if (!skb2)
7724                 return -ENOMEM;
7725
7726         err = nf_tables_fill_flowtable_info(skb2, net, NETLINK_CB(skb).portid,
7727                                             info->nlh->nlmsg_seq,
7728                                             NFT_MSG_NEWFLOWTABLE, 0, family,
7729                                             flowtable, &flowtable->hook_list);
7730         if (err < 0)
7731                 goto err_fill_flowtable_info;
7732
7733         return nfnetlink_unicast(skb2, net, NETLINK_CB(skb).portid);
7734
7735 err_fill_flowtable_info:
7736         kfree_skb(skb2);
7737         return err;
7738 }
7739
7740 static void nf_tables_flowtable_notify(struct nft_ctx *ctx,
7741                                        struct nft_flowtable *flowtable,
7742                                        struct list_head *hook_list,
7743                                        int event)
7744 {
7745         struct nftables_pernet *nft_net = nft_pernet(ctx->net);
7746         struct sk_buff *skb;
7747         int err;
7748
7749         if (!ctx->report &&
7750             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
7751                 return;
7752
7753         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
7754         if (skb == NULL)
7755                 goto err;
7756
7757         err = nf_tables_fill_flowtable_info(skb, ctx->net, ctx->portid,
7758                                             ctx->seq, event, 0,
7759                                             ctx->family, flowtable, hook_list);
7760         if (err < 0) {
7761                 kfree_skb(skb);
7762                 goto err;
7763         }
7764
7765         nft_notify_enqueue(skb, ctx->report, &nft_net->notify_list);
7766         return;
7767 err:
7768         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
7769 }
7770
7771 static void nf_tables_flowtable_destroy(struct nft_flowtable *flowtable)
7772 {
7773         struct nft_hook *hook, *next;
7774
7775         flowtable->data.type->free(&flowtable->data);
7776         list_for_each_entry_safe(hook, next, &flowtable->hook_list, list) {
7777                 flowtable->data.type->setup(&flowtable->data, hook->ops.dev,
7778                                             FLOW_BLOCK_UNBIND);
7779                 list_del_rcu(&hook->list);
7780                 kfree(hook);
7781         }
7782         kfree(flowtable->name);
7783         module_put(flowtable->data.type->owner);
7784         kfree(flowtable);
7785 }
7786
7787 static int nf_tables_fill_gen_info(struct sk_buff *skb, struct net *net,
7788                                    u32 portid, u32 seq)
7789 {
7790         struct nftables_pernet *nft_net = nft_pernet(net);
7791         struct nlmsghdr *nlh;
7792         char buf[TASK_COMM_LEN];
7793         int event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWGEN);
7794
7795         nlh = nfnl_msg_put(skb, portid, seq, event, 0, AF_UNSPEC,
7796                            NFNETLINK_V0, nft_base_seq(net));
7797         if (!nlh)
7798                 goto nla_put_failure;
7799
7800         if (nla_put_be32(skb, NFTA_GEN_ID, htonl(nft_net->base_seq)) ||
7801             nla_put_be32(skb, NFTA_GEN_PROC_PID, htonl(task_pid_nr(current))) ||
7802             nla_put_string(skb, NFTA_GEN_PROC_NAME, get_task_comm(buf, current)))
7803                 goto nla_put_failure;
7804
7805         nlmsg_end(skb, nlh);
7806         return 0;
7807
7808 nla_put_failure:
7809         nlmsg_trim(skb, nlh);
7810         return -EMSGSIZE;
7811 }
7812
7813 static void nft_flowtable_event(unsigned long event, struct net_device *dev,
7814                                 struct nft_flowtable *flowtable)
7815 {
7816         struct nft_hook *hook;
7817
7818         list_for_each_entry(hook, &flowtable->hook_list, list) {
7819                 if (hook->ops.dev != dev)
7820                         continue;
7821
7822                 /* flow_offload_netdev_event() cleans up entries for us. */
7823                 nft_unregister_flowtable_hook(dev_net(dev), flowtable, hook);
7824                 list_del_rcu(&hook->list);
7825                 kfree_rcu(hook, rcu);
7826                 break;
7827         }
7828 }
7829
7830 static int nf_tables_flowtable_event(struct notifier_block *this,
7831                                      unsigned long event, void *ptr)
7832 {
7833         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
7834         struct nft_flowtable *flowtable;
7835         struct nftables_pernet *nft_net;
7836         struct nft_table *table;
7837         struct net *net;
7838
7839         if (event != NETDEV_UNREGISTER)
7840                 return 0;
7841
7842         net = dev_net(dev);
7843         nft_net = nft_pernet(net);
7844         mutex_lock(&nft_net->commit_mutex);
7845         list_for_each_entry(table, &nft_net->tables, list) {
7846                 list_for_each_entry(flowtable, &table->flowtables, list) {
7847                         nft_flowtable_event(event, dev, flowtable);
7848                 }
7849         }
7850         mutex_unlock(&nft_net->commit_mutex);
7851
7852         return NOTIFY_DONE;
7853 }
7854
7855 static struct notifier_block nf_tables_flowtable_notifier = {
7856         .notifier_call  = nf_tables_flowtable_event,
7857 };
7858
7859 static void nf_tables_gen_notify(struct net *net, struct sk_buff *skb,
7860                                  int event)
7861 {
7862         struct nlmsghdr *nlh = nlmsg_hdr(skb);
7863         struct sk_buff *skb2;
7864         int err;
7865
7866         if (!nlmsg_report(nlh) &&
7867             !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
7868                 return;
7869
7870         skb2 = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
7871         if (skb2 == NULL)
7872                 goto err;
7873
7874         err = nf_tables_fill_gen_info(skb2, net, NETLINK_CB(skb).portid,
7875                                       nlh->nlmsg_seq);
7876         if (err < 0) {
7877                 kfree_skb(skb2);
7878                 goto err;
7879         }
7880
7881         nfnetlink_send(skb2, net, NETLINK_CB(skb).portid, NFNLGRP_NFTABLES,
7882                        nlmsg_report(nlh), GFP_KERNEL);
7883         return;
7884 err:
7885         nfnetlink_set_err(net, NETLINK_CB(skb).portid, NFNLGRP_NFTABLES,
7886                           -ENOBUFS);
7887 }
7888
7889 static int nf_tables_getgen(struct sk_buff *skb, const struct nfnl_info *info,
7890                             const struct nlattr * const nla[])
7891 {
7892         struct sk_buff *skb2;
7893         int err;
7894
7895         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_ATOMIC);
7896         if (skb2 == NULL)
7897                 return -ENOMEM;
7898
7899         err = nf_tables_fill_gen_info(skb2, info->net, NETLINK_CB(skb).portid,
7900                                       info->nlh->nlmsg_seq);
7901         if (err < 0)
7902                 goto err_fill_gen_info;
7903
7904         return nfnetlink_unicast(skb2, info->net, NETLINK_CB(skb).portid);
7905
7906 err_fill_gen_info:
7907         kfree_skb(skb2);
7908         return err;
7909 }
7910
7911 static const struct nfnl_callback nf_tables_cb[NFT_MSG_MAX] = {
7912         [NFT_MSG_NEWTABLE] = {
7913                 .call           = nf_tables_newtable,
7914                 .type           = NFNL_CB_BATCH,
7915                 .attr_count     = NFTA_TABLE_MAX,
7916                 .policy         = nft_table_policy,
7917         },
7918         [NFT_MSG_GETTABLE] = {
7919                 .call           = nf_tables_gettable,
7920                 .type           = NFNL_CB_RCU,
7921                 .attr_count     = NFTA_TABLE_MAX,
7922                 .policy         = nft_table_policy,
7923         },
7924         [NFT_MSG_DELTABLE] = {
7925                 .call           = nf_tables_deltable,
7926                 .type           = NFNL_CB_BATCH,
7927                 .attr_count     = NFTA_TABLE_MAX,
7928                 .policy         = nft_table_policy,
7929         },
7930         [NFT_MSG_NEWCHAIN] = {
7931                 .call           = nf_tables_newchain,
7932                 .type           = NFNL_CB_BATCH,
7933                 .attr_count     = NFTA_CHAIN_MAX,
7934                 .policy         = nft_chain_policy,
7935         },
7936         [NFT_MSG_GETCHAIN] = {
7937                 .call           = nf_tables_getchain,
7938                 .type           = NFNL_CB_RCU,
7939                 .attr_count     = NFTA_CHAIN_MAX,
7940                 .policy         = nft_chain_policy,
7941         },
7942         [NFT_MSG_DELCHAIN] = {
7943                 .call           = nf_tables_delchain,
7944                 .type           = NFNL_CB_BATCH,
7945                 .attr_count     = NFTA_CHAIN_MAX,
7946                 .policy         = nft_chain_policy,
7947         },
7948         [NFT_MSG_NEWRULE] = {
7949                 .call           = nf_tables_newrule,
7950                 .type           = NFNL_CB_BATCH,
7951                 .attr_count     = NFTA_RULE_MAX,
7952                 .policy         = nft_rule_policy,
7953         },
7954         [NFT_MSG_GETRULE] = {
7955                 .call           = nf_tables_getrule,
7956                 .type           = NFNL_CB_RCU,
7957                 .attr_count     = NFTA_RULE_MAX,
7958                 .policy         = nft_rule_policy,
7959         },
7960         [NFT_MSG_DELRULE] = {
7961                 .call           = nf_tables_delrule,
7962                 .type           = NFNL_CB_BATCH,
7963                 .attr_count     = NFTA_RULE_MAX,
7964                 .policy         = nft_rule_policy,
7965         },
7966         [NFT_MSG_NEWSET] = {
7967                 .call           = nf_tables_newset,
7968                 .type           = NFNL_CB_BATCH,
7969                 .attr_count     = NFTA_SET_MAX,
7970                 .policy         = nft_set_policy,
7971         },
7972         [NFT_MSG_GETSET] = {
7973                 .call           = nf_tables_getset,
7974                 .type           = NFNL_CB_RCU,
7975                 .attr_count     = NFTA_SET_MAX,
7976                 .policy         = nft_set_policy,
7977         },
7978         [NFT_MSG_DELSET] = {
7979                 .call           = nf_tables_delset,
7980                 .type           = NFNL_CB_BATCH,
7981                 .attr_count     = NFTA_SET_MAX,
7982                 .policy         = nft_set_policy,
7983         },
7984         [NFT_MSG_NEWSETELEM] = {
7985                 .call           = nf_tables_newsetelem,
7986                 .type           = NFNL_CB_BATCH,
7987                 .attr_count     = NFTA_SET_ELEM_LIST_MAX,
7988                 .policy         = nft_set_elem_list_policy,
7989         },
7990         [NFT_MSG_GETSETELEM] = {
7991                 .call           = nf_tables_getsetelem,
7992                 .type           = NFNL_CB_RCU,
7993                 .attr_count     = NFTA_SET_ELEM_LIST_MAX,
7994                 .policy         = nft_set_elem_list_policy,
7995         },
7996         [NFT_MSG_DELSETELEM] = {
7997                 .call           = nf_tables_delsetelem,
7998                 .type           = NFNL_CB_BATCH,
7999                 .attr_count     = NFTA_SET_ELEM_LIST_MAX,
8000                 .policy         = nft_set_elem_list_policy,
8001         },
8002         [NFT_MSG_GETGEN] = {
8003                 .call           = nf_tables_getgen,
8004                 .type           = NFNL_CB_RCU,
8005         },
8006         [NFT_MSG_NEWOBJ] = {
8007                 .call           = nf_tables_newobj,
8008                 .type           = NFNL_CB_BATCH,
8009                 .attr_count     = NFTA_OBJ_MAX,
8010                 .policy         = nft_obj_policy,
8011         },
8012         [NFT_MSG_GETOBJ] = {
8013                 .call           = nf_tables_getobj,
8014                 .type           = NFNL_CB_RCU,
8015                 .attr_count     = NFTA_OBJ_MAX,
8016                 .policy         = nft_obj_policy,
8017         },
8018         [NFT_MSG_DELOBJ] = {
8019                 .call           = nf_tables_delobj,
8020                 .type           = NFNL_CB_BATCH,
8021                 .attr_count     = NFTA_OBJ_MAX,
8022                 .policy         = nft_obj_policy,
8023         },
8024         [NFT_MSG_GETOBJ_RESET] = {
8025                 .call           = nf_tables_getobj,
8026                 .type           = NFNL_CB_RCU,
8027                 .attr_count     = NFTA_OBJ_MAX,
8028                 .policy         = nft_obj_policy,
8029         },
8030         [NFT_MSG_NEWFLOWTABLE] = {
8031                 .call           = nf_tables_newflowtable,
8032                 .type           = NFNL_CB_BATCH,
8033                 .attr_count     = NFTA_FLOWTABLE_MAX,
8034                 .policy         = nft_flowtable_policy,
8035         },
8036         [NFT_MSG_GETFLOWTABLE] = {
8037                 .call           = nf_tables_getflowtable,
8038                 .type           = NFNL_CB_RCU,
8039                 .attr_count     = NFTA_FLOWTABLE_MAX,
8040                 .policy         = nft_flowtable_policy,
8041         },
8042         [NFT_MSG_DELFLOWTABLE] = {
8043                 .call           = nf_tables_delflowtable,
8044                 .type           = NFNL_CB_BATCH,
8045                 .attr_count     = NFTA_FLOWTABLE_MAX,
8046                 .policy         = nft_flowtable_policy,
8047         },
8048 };
8049
8050 static int nf_tables_validate(struct net *net)
8051 {
8052         struct nftables_pernet *nft_net = nft_pernet(net);
8053         struct nft_table *table;
8054
8055         switch (nft_net->validate_state) {
8056         case NFT_VALIDATE_SKIP:
8057                 break;
8058         case NFT_VALIDATE_NEED:
8059                 nft_validate_state_update(net, NFT_VALIDATE_DO);
8060                 fallthrough;
8061         case NFT_VALIDATE_DO:
8062                 list_for_each_entry(table, &nft_net->tables, list) {
8063                         if (nft_table_validate(net, table) < 0)
8064                                 return -EAGAIN;
8065                 }
8066                 break;
8067         }
8068
8069         return 0;
8070 }
8071
8072 /* a drop policy has to be deferred until all rules have been activated,
8073  * otherwise a large ruleset that contains a drop-policy base chain will
8074  * cause all packets to get dropped until the full transaction has been
8075  * processed.
8076  *
8077  * We defer the drop policy until the transaction has been finalized.
8078  */
8079 static void nft_chain_commit_drop_policy(struct nft_trans *trans)
8080 {
8081         struct nft_base_chain *basechain;
8082
8083         if (nft_trans_chain_policy(trans) != NF_DROP)
8084                 return;
8085
8086         if (!nft_is_base_chain(trans->ctx.chain))
8087                 return;
8088
8089         basechain = nft_base_chain(trans->ctx.chain);
8090         basechain->policy = NF_DROP;
8091 }
8092
8093 static void nft_chain_commit_update(struct nft_trans *trans)
8094 {
8095         struct nft_base_chain *basechain;
8096
8097         if (nft_trans_chain_name(trans)) {
8098                 rhltable_remove(&trans->ctx.table->chains_ht,
8099                                 &trans->ctx.chain->rhlhead,
8100                                 nft_chain_ht_params);
8101                 swap(trans->ctx.chain->name, nft_trans_chain_name(trans));
8102                 rhltable_insert_key(&trans->ctx.table->chains_ht,
8103                                     trans->ctx.chain->name,
8104                                     &trans->ctx.chain->rhlhead,
8105                                     nft_chain_ht_params);
8106         }
8107
8108         if (!nft_is_base_chain(trans->ctx.chain))
8109                 return;
8110
8111         nft_chain_stats_replace(trans);
8112
8113         basechain = nft_base_chain(trans->ctx.chain);
8114
8115         switch (nft_trans_chain_policy(trans)) {
8116         case NF_DROP:
8117         case NF_ACCEPT:
8118                 basechain->policy = nft_trans_chain_policy(trans);
8119                 break;
8120         }
8121 }
8122
8123 static void nft_obj_commit_update(struct nft_trans *trans)
8124 {
8125         struct nft_object *newobj;
8126         struct nft_object *obj;
8127
8128         obj = nft_trans_obj(trans);
8129         newobj = nft_trans_obj_newobj(trans);
8130
8131         if (obj->ops->update)
8132                 obj->ops->update(obj, newobj);
8133
8134         kfree(newobj);
8135 }
8136
8137 static void nft_commit_release(struct nft_trans *trans)
8138 {
8139         switch (trans->msg_type) {
8140         case NFT_MSG_DELTABLE:
8141                 nf_tables_table_destroy(&trans->ctx);
8142                 break;
8143         case NFT_MSG_NEWCHAIN:
8144                 free_percpu(nft_trans_chain_stats(trans));
8145                 kfree(nft_trans_chain_name(trans));
8146                 break;
8147         case NFT_MSG_DELCHAIN:
8148                 nf_tables_chain_destroy(&trans->ctx);
8149                 break;
8150         case NFT_MSG_DELRULE:
8151                 nf_tables_rule_destroy(&trans->ctx, nft_trans_rule(trans));
8152                 break;
8153         case NFT_MSG_DELSET:
8154                 nft_set_destroy(&trans->ctx, nft_trans_set(trans));
8155                 break;
8156         case NFT_MSG_DELSETELEM:
8157                 nf_tables_set_elem_destroy(&trans->ctx,
8158                                            nft_trans_elem_set(trans),
8159                                            nft_trans_elem(trans).priv);
8160                 break;
8161         case NFT_MSG_DELOBJ:
8162                 nft_obj_destroy(&trans->ctx, nft_trans_obj(trans));
8163                 break;
8164         case NFT_MSG_DELFLOWTABLE:
8165                 if (nft_trans_flowtable_update(trans))
8166                         nft_flowtable_hooks_destroy(&nft_trans_flowtable_hooks(trans));
8167                 else
8168                         nf_tables_flowtable_destroy(nft_trans_flowtable(trans));
8169                 break;
8170         }
8171
8172         if (trans->put_net)
8173                 put_net(trans->ctx.net);
8174
8175         kfree(trans);
8176 }
8177
8178 static void nf_tables_trans_destroy_work(struct work_struct *w)
8179 {
8180         struct nft_trans *trans, *next;
8181         LIST_HEAD(head);
8182
8183         spin_lock(&nf_tables_destroy_list_lock);
8184         list_splice_init(&nf_tables_destroy_list, &head);
8185         spin_unlock(&nf_tables_destroy_list_lock);
8186
8187         if (list_empty(&head))
8188                 return;
8189
8190         synchronize_rcu();
8191
8192         list_for_each_entry_safe(trans, next, &head, list) {
8193                 list_del(&trans->list);
8194                 nft_commit_release(trans);
8195         }
8196 }
8197
8198 void nf_tables_trans_destroy_flush_work(void)
8199 {
8200         flush_work(&trans_destroy_work);
8201 }
8202 EXPORT_SYMBOL_GPL(nf_tables_trans_destroy_flush_work);
8203
8204 static int nf_tables_commit_chain_prepare(struct net *net, struct nft_chain *chain)
8205 {
8206         struct nft_rule *rule;
8207         unsigned int alloc = 0;
8208         int i;
8209
8210         /* already handled or inactive chain? */
8211         if (chain->rules_next || !nft_is_active_next(net, chain))
8212                 return 0;
8213
8214         rule = list_entry(&chain->rules, struct nft_rule, list);
8215         i = 0;
8216
8217         list_for_each_entry_continue(rule, &chain->rules, list) {
8218                 if (nft_is_active_next(net, rule))
8219                         alloc++;
8220         }
8221
8222         chain->rules_next = nf_tables_chain_alloc_rules(chain, alloc);
8223         if (!chain->rules_next)
8224                 return -ENOMEM;
8225
8226         list_for_each_entry_continue(rule, &chain->rules, list) {
8227                 if (nft_is_active_next(net, rule))
8228                         chain->rules_next[i++] = rule;
8229         }
8230
8231         chain->rules_next[i] = NULL;
8232         return 0;
8233 }
8234
8235 static void nf_tables_commit_chain_prepare_cancel(struct net *net)
8236 {
8237         struct nftables_pernet *nft_net = nft_pernet(net);
8238         struct nft_trans *trans, *next;
8239
8240         list_for_each_entry_safe(trans, next, &nft_net->commit_list, list) {
8241                 struct nft_chain *chain = trans->ctx.chain;
8242
8243                 if (trans->msg_type == NFT_MSG_NEWRULE ||
8244                     trans->msg_type == NFT_MSG_DELRULE) {
8245                         kvfree(chain->rules_next);
8246                         chain->rules_next = NULL;
8247                 }
8248         }
8249 }
8250
8251 static void __nf_tables_commit_chain_free_rules_old(struct rcu_head *h)
8252 {
8253         struct nft_rules_old *o = container_of(h, struct nft_rules_old, h);
8254
8255         kvfree(o->start);
8256 }
8257
8258 static void nf_tables_commit_chain_free_rules_old(struct nft_rule **rules)
8259 {
8260         struct nft_rule **r = rules;
8261         struct nft_rules_old *old;
8262
8263         while (*r)
8264                 r++;
8265
8266         r++;    /* rcu_head is after end marker */
8267         old = (void *) r;
8268         old->start = rules;
8269
8270         call_rcu(&old->h, __nf_tables_commit_chain_free_rules_old);
8271 }
8272
8273 static void nf_tables_commit_chain(struct net *net, struct nft_chain *chain)
8274 {
8275         struct nft_rule **g0, **g1;
8276         bool next_genbit;
8277
8278         next_genbit = nft_gencursor_next(net);
8279
8280         g0 = rcu_dereference_protected(chain->rules_gen_0,
8281                                        lockdep_commit_lock_is_held(net));
8282         g1 = rcu_dereference_protected(chain->rules_gen_1,
8283                                        lockdep_commit_lock_is_held(net));
8284
8285         /* No changes to this chain? */
8286         if (chain->rules_next == NULL) {
8287                 /* chain had no change in last or next generation */
8288                 if (g0 == g1)
8289                         return;
8290                 /*
8291                  * chain had no change in this generation; make sure next
8292                  * one uses same rules as current generation.
8293                  */
8294                 if (next_genbit) {
8295                         rcu_assign_pointer(chain->rules_gen_1, g0);
8296                         nf_tables_commit_chain_free_rules_old(g1);
8297                 } else {
8298                         rcu_assign_pointer(chain->rules_gen_0, g1);
8299                         nf_tables_commit_chain_free_rules_old(g0);
8300                 }
8301
8302                 return;
8303         }
8304
8305         if (next_genbit)
8306                 rcu_assign_pointer(chain->rules_gen_1, chain->rules_next);
8307         else
8308                 rcu_assign_pointer(chain->rules_gen_0, chain->rules_next);
8309
8310         chain->rules_next = NULL;
8311
8312         if (g0 == g1)
8313                 return;
8314
8315         if (next_genbit)
8316                 nf_tables_commit_chain_free_rules_old(g1);
8317         else
8318                 nf_tables_commit_chain_free_rules_old(g0);
8319 }
8320
8321 static void nft_obj_del(struct nft_object *obj)
8322 {
8323         rhltable_remove(&nft_objname_ht, &obj->rhlhead, nft_objname_ht_params);
8324         list_del_rcu(&obj->list);
8325 }
8326
8327 void nft_chain_del(struct nft_chain *chain)
8328 {
8329         struct nft_table *table = chain->table;
8330
8331         WARN_ON_ONCE(rhltable_remove(&table->chains_ht, &chain->rhlhead,
8332                                      nft_chain_ht_params));
8333         list_del_rcu(&chain->list);
8334 }
8335
8336 static void nft_flowtable_hooks_del(struct nft_flowtable *flowtable,
8337                                     struct list_head *hook_list)
8338 {
8339         struct nft_hook *hook, *next;
8340
8341         list_for_each_entry_safe(hook, next, &flowtable->hook_list, list) {
8342                 if (hook->inactive)
8343                         list_move(&hook->list, hook_list);
8344         }
8345 }
8346
8347 static void nf_tables_module_autoload_cleanup(struct net *net)
8348 {
8349         struct nftables_pernet *nft_net = nft_pernet(net);
8350         struct nft_module_request *req, *next;
8351
8352         WARN_ON_ONCE(!list_empty(&nft_net->commit_list));
8353         list_for_each_entry_safe(req, next, &nft_net->module_list, list) {
8354                 WARN_ON_ONCE(!req->done);
8355                 list_del(&req->list);
8356                 kfree(req);
8357         }
8358 }
8359
8360 static void nf_tables_commit_release(struct net *net)
8361 {
8362         struct nftables_pernet *nft_net = nft_pernet(net);
8363         struct nft_trans *trans;
8364
8365         /* all side effects have to be made visible.
8366          * For example, if a chain named 'foo' has been deleted, a
8367          * new transaction must not find it anymore.
8368          *
8369          * Memory reclaim happens asynchronously from work queue
8370          * to prevent expensive synchronize_rcu() in commit phase.
8371          */
8372         if (list_empty(&nft_net->commit_list)) {
8373                 nf_tables_module_autoload_cleanup(net);
8374                 mutex_unlock(&nft_net->commit_mutex);
8375                 return;
8376         }
8377
8378         trans = list_last_entry(&nft_net->commit_list,
8379                                 struct nft_trans, list);
8380         get_net(trans->ctx.net);
8381         WARN_ON_ONCE(trans->put_net);
8382
8383         trans->put_net = true;
8384         spin_lock(&nf_tables_destroy_list_lock);
8385         list_splice_tail_init(&nft_net->commit_list, &nf_tables_destroy_list);
8386         spin_unlock(&nf_tables_destroy_list_lock);
8387
8388         nf_tables_module_autoload_cleanup(net);
8389         schedule_work(&trans_destroy_work);
8390
8391         mutex_unlock(&nft_net->commit_mutex);
8392 }
8393
8394 static void nft_commit_notify(struct net *net, u32 portid)
8395 {
8396         struct nftables_pernet *nft_net = nft_pernet(net);
8397         struct sk_buff *batch_skb = NULL, *nskb, *skb;
8398         unsigned char *data;
8399         int len;
8400
8401         list_for_each_entry_safe(skb, nskb, &nft_net->notify_list, list) {
8402                 if (!batch_skb) {
8403 new_batch:
8404                         batch_skb = skb;
8405                         len = NLMSG_GOODSIZE - skb->len;
8406                         list_del(&skb->list);
8407                         continue;
8408                 }
8409                 len -= skb->len;
8410                 if (len > 0 && NFT_CB(skb).report == NFT_CB(batch_skb).report) {
8411                         data = skb_put(batch_skb, skb->len);
8412                         memcpy(data, skb->data, skb->len);
8413                         list_del(&skb->list);
8414                         kfree_skb(skb);
8415                         continue;
8416                 }
8417                 nfnetlink_send(batch_skb, net, portid, NFNLGRP_NFTABLES,
8418                                NFT_CB(batch_skb).report, GFP_KERNEL);
8419                 goto new_batch;
8420         }
8421
8422         if (batch_skb) {
8423                 nfnetlink_send(batch_skb, net, portid, NFNLGRP_NFTABLES,
8424                                NFT_CB(batch_skb).report, GFP_KERNEL);
8425         }
8426
8427         WARN_ON_ONCE(!list_empty(&nft_net->notify_list));
8428 }
8429
8430 static int nf_tables_commit_audit_alloc(struct list_head *adl,
8431                                         struct nft_table *table)
8432 {
8433         struct nft_audit_data *adp;
8434
8435         list_for_each_entry(adp, adl, list) {
8436                 if (adp->table == table)
8437                         return 0;
8438         }
8439         adp = kzalloc(sizeof(*adp), GFP_KERNEL);
8440         if (!adp)
8441                 return -ENOMEM;
8442         adp->table = table;
8443         list_add(&adp->list, adl);
8444         return 0;
8445 }
8446
8447 static void nf_tables_commit_audit_collect(struct list_head *adl,
8448                                            struct nft_table *table, u32 op)
8449 {
8450         struct nft_audit_data *adp;
8451
8452         list_for_each_entry(adp, adl, list) {
8453                 if (adp->table == table)
8454                         goto found;
8455         }
8456         WARN_ONCE(1, "table=%s not expected in commit list", table->name);
8457         return;
8458 found:
8459         adp->entries++;
8460         if (!adp->op || adp->op > op)
8461                 adp->op = op;
8462 }
8463
8464 #define AUNFTABLENAMELEN (NFT_TABLE_MAXNAMELEN + 22)
8465
8466 static void nf_tables_commit_audit_log(struct list_head *adl, u32 generation)
8467 {
8468         struct nft_audit_data *adp, *adn;
8469         char aubuf[AUNFTABLENAMELEN];
8470
8471         list_for_each_entry_safe(adp, adn, adl, list) {
8472                 snprintf(aubuf, AUNFTABLENAMELEN, "%s:%u", adp->table->name,
8473                          generation);
8474                 audit_log_nfcfg(aubuf, adp->table->family, adp->entries,
8475                                 nft2audit_op[adp->op], GFP_KERNEL);
8476                 list_del(&adp->list);
8477                 kfree(adp);
8478         }
8479 }
8480
8481 static int nf_tables_commit(struct net *net, struct sk_buff *skb)
8482 {
8483         struct nftables_pernet *nft_net = nft_pernet(net);
8484         struct nft_trans *trans, *next;
8485         struct nft_trans_elem *te;
8486         struct nft_chain *chain;
8487         struct nft_table *table;
8488         LIST_HEAD(adl);
8489         int err;
8490
8491         if (list_empty(&nft_net->commit_list)) {
8492                 mutex_unlock(&nft_net->commit_mutex);
8493                 return 0;
8494         }
8495
8496         /* 0. Validate ruleset, otherwise roll back for error reporting. */
8497         if (nf_tables_validate(net) < 0)
8498                 return -EAGAIN;
8499
8500         err = nft_flow_rule_offload_commit(net);
8501         if (err < 0)
8502                 return err;
8503
8504         /* 1.  Allocate space for next generation rules_gen_X[] */
8505         list_for_each_entry_safe(trans, next, &nft_net->commit_list, list) {
8506                 int ret;
8507
8508                 ret = nf_tables_commit_audit_alloc(&adl, trans->ctx.table);
8509                 if (ret) {
8510                         nf_tables_commit_chain_prepare_cancel(net);
8511                         return ret;
8512                 }
8513                 if (trans->msg_type == NFT_MSG_NEWRULE ||
8514                     trans->msg_type == NFT_MSG_DELRULE) {
8515                         chain = trans->ctx.chain;
8516
8517                         ret = nf_tables_commit_chain_prepare(net, chain);
8518                         if (ret < 0) {
8519                                 nf_tables_commit_chain_prepare_cancel(net);
8520                                 return ret;
8521                         }
8522                 }
8523         }
8524
8525         /* step 2.  Make rules_gen_X visible to packet path */
8526         list_for_each_entry(table, &nft_net->tables, list) {
8527                 list_for_each_entry(chain, &table->chains, list)
8528                         nf_tables_commit_chain(net, chain);
8529         }
8530
8531         /*
8532          * Bump generation counter, invalidate any dump in progress.
8533          * Cannot fail after this point.
8534          */
8535         while (++nft_net->base_seq == 0)
8536                 ;
8537
8538         /* step 3. Start new generation, rules_gen_X now in use. */
8539         net->nft.gencursor = nft_gencursor_next(net);
8540
8541         list_for_each_entry_safe(trans, next, &nft_net->commit_list, list) {
8542                 nf_tables_commit_audit_collect(&adl, trans->ctx.table,
8543                                                trans->msg_type);
8544                 switch (trans->msg_type) {
8545                 case NFT_MSG_NEWTABLE:
8546                         if (nft_trans_table_update(trans)) {
8547                                 if (!(trans->ctx.table->flags & __NFT_TABLE_F_UPDATE)) {
8548                                         nft_trans_destroy(trans);
8549                                         break;
8550                                 }
8551                                 if (trans->ctx.table->flags & NFT_TABLE_F_DORMANT)
8552                                         nf_tables_table_disable(net, trans->ctx.table);
8553
8554                                 trans->ctx.table->flags &= ~__NFT_TABLE_F_UPDATE;
8555                         } else {
8556                                 nft_clear(net, trans->ctx.table);
8557                         }
8558                         nf_tables_table_notify(&trans->ctx, NFT_MSG_NEWTABLE);
8559                         nft_trans_destroy(trans);
8560                         break;
8561                 case NFT_MSG_DELTABLE:
8562                         list_del_rcu(&trans->ctx.table->list);
8563                         nf_tables_table_notify(&trans->ctx, NFT_MSG_DELTABLE);
8564                         break;
8565                 case NFT_MSG_NEWCHAIN:
8566                         if (nft_trans_chain_update(trans)) {
8567                                 nft_chain_commit_update(trans);
8568                                 nf_tables_chain_notify(&trans->ctx, NFT_MSG_NEWCHAIN);
8569                                 /* trans destroyed after rcu grace period */
8570                         } else {
8571                                 nft_chain_commit_drop_policy(trans);
8572                                 nft_clear(net, trans->ctx.chain);
8573                                 nf_tables_chain_notify(&trans->ctx, NFT_MSG_NEWCHAIN);
8574                                 nft_trans_destroy(trans);
8575                         }
8576                         break;
8577                 case NFT_MSG_DELCHAIN:
8578                         nft_chain_del(trans->ctx.chain);
8579                         nf_tables_chain_notify(&trans->ctx, NFT_MSG_DELCHAIN);
8580                         nf_tables_unregister_hook(trans->ctx.net,
8581                                                   trans->ctx.table,
8582                                                   trans->ctx.chain);
8583                         break;
8584                 case NFT_MSG_NEWRULE:
8585                         nft_clear(trans->ctx.net, nft_trans_rule(trans));
8586                         nf_tables_rule_notify(&trans->ctx,
8587                                               nft_trans_rule(trans),
8588                                               NFT_MSG_NEWRULE);
8589                         nft_trans_destroy(trans);
8590                         break;
8591                 case NFT_MSG_DELRULE:
8592                         list_del_rcu(&nft_trans_rule(trans)->list);
8593                         nf_tables_rule_notify(&trans->ctx,
8594                                               nft_trans_rule(trans),
8595                                               NFT_MSG_DELRULE);
8596                         nft_rule_expr_deactivate(&trans->ctx,
8597                                                  nft_trans_rule(trans),
8598                                                  NFT_TRANS_COMMIT);
8599                         break;
8600                 case NFT_MSG_NEWSET:
8601                         nft_clear(net, nft_trans_set(trans));
8602                         /* This avoids hitting -EBUSY when deleting the table
8603                          * from the transaction.
8604                          */
8605                         if (nft_set_is_anonymous(nft_trans_set(trans)) &&
8606                             !list_empty(&nft_trans_set(trans)->bindings))
8607                                 trans->ctx.table->use--;
8608
8609                         nf_tables_set_notify(&trans->ctx, nft_trans_set(trans),
8610                                              NFT_MSG_NEWSET, GFP_KERNEL);
8611                         nft_trans_destroy(trans);
8612                         break;
8613                 case NFT_MSG_DELSET:
8614                         list_del_rcu(&nft_trans_set(trans)->list);
8615                         nf_tables_set_notify(&trans->ctx, nft_trans_set(trans),
8616                                              NFT_MSG_DELSET, GFP_KERNEL);
8617                         break;
8618                 case NFT_MSG_NEWSETELEM:
8619                         te = (struct nft_trans_elem *)trans->data;
8620
8621                         nft_setelem_activate(net, te->set, &te->elem);
8622                         nf_tables_setelem_notify(&trans->ctx, te->set,
8623                                                  &te->elem,
8624                                                  NFT_MSG_NEWSETELEM, 0);
8625                         nft_trans_destroy(trans);
8626                         break;
8627                 case NFT_MSG_DELSETELEM:
8628                         te = (struct nft_trans_elem *)trans->data;
8629
8630                         nf_tables_setelem_notify(&trans->ctx, te->set,
8631                                                  &te->elem,
8632                                                  NFT_MSG_DELSETELEM, 0);
8633                         nft_setelem_remove(net, te->set, &te->elem);
8634                         if (!nft_setelem_is_catchall(te->set, &te->elem)) {
8635                                 atomic_dec(&te->set->nelems);
8636                                 te->set->ndeact--;
8637                         }
8638                         break;
8639                 case NFT_MSG_NEWOBJ:
8640                         if (nft_trans_obj_update(trans)) {
8641                                 nft_obj_commit_update(trans);
8642                                 nf_tables_obj_notify(&trans->ctx,
8643                                                      nft_trans_obj(trans),
8644                                                      NFT_MSG_NEWOBJ);
8645                         } else {
8646                                 nft_clear(net, nft_trans_obj(trans));
8647                                 nf_tables_obj_notify(&trans->ctx,
8648                                                      nft_trans_obj(trans),
8649                                                      NFT_MSG_NEWOBJ);
8650                                 nft_trans_destroy(trans);
8651                         }
8652                         break;
8653                 case NFT_MSG_DELOBJ:
8654                         nft_obj_del(nft_trans_obj(trans));
8655                         nf_tables_obj_notify(&trans->ctx, nft_trans_obj(trans),
8656                                              NFT_MSG_DELOBJ);
8657                         break;
8658                 case NFT_MSG_NEWFLOWTABLE:
8659                         if (nft_trans_flowtable_update(trans)) {
8660                                 nft_trans_flowtable(trans)->data.flags =
8661                                         nft_trans_flowtable_flags(trans);
8662                                 nf_tables_flowtable_notify(&trans->ctx,
8663                                                            nft_trans_flowtable(trans),
8664                                                            &nft_trans_flowtable_hooks(trans),
8665                                                            NFT_MSG_NEWFLOWTABLE);
8666                                 list_splice(&nft_trans_flowtable_hooks(trans),
8667                                             &nft_trans_flowtable(trans)->hook_list);
8668                         } else {
8669                                 nft_clear(net, nft_trans_flowtable(trans));
8670                                 nf_tables_flowtable_notify(&trans->ctx,
8671                                                            nft_trans_flowtable(trans),
8672                                                            &nft_trans_flowtable(trans)->hook_list,
8673                                                            NFT_MSG_NEWFLOWTABLE);
8674                         }
8675                         nft_trans_destroy(trans);
8676                         break;
8677                 case NFT_MSG_DELFLOWTABLE:
8678                         if (nft_trans_flowtable_update(trans)) {
8679                                 nft_flowtable_hooks_del(nft_trans_flowtable(trans),
8680                                                         &nft_trans_flowtable_hooks(trans));
8681                                 nf_tables_flowtable_notify(&trans->ctx,
8682                                                            nft_trans_flowtable(trans),
8683                                                            &nft_trans_flowtable_hooks(trans),
8684                                                            NFT_MSG_DELFLOWTABLE);
8685                                 nft_unregister_flowtable_net_hooks(net,
8686                                                                    &nft_trans_flowtable_hooks(trans));
8687                         } else {
8688                                 list_del_rcu(&nft_trans_flowtable(trans)->list);
8689                                 nf_tables_flowtable_notify(&trans->ctx,
8690                                                            nft_trans_flowtable(trans),
8691                                                            &nft_trans_flowtable(trans)->hook_list,
8692                                                            NFT_MSG_DELFLOWTABLE);
8693                                 nft_unregister_flowtable_net_hooks(net,
8694                                                 &nft_trans_flowtable(trans)->hook_list);
8695                         }
8696                         break;
8697                 }
8698         }
8699
8700         nft_commit_notify(net, NETLINK_CB(skb).portid);
8701         nf_tables_gen_notify(net, skb, NFT_MSG_NEWGEN);
8702         nf_tables_commit_audit_log(&adl, nft_net->base_seq);
8703         nf_tables_commit_release(net);
8704
8705         return 0;
8706 }
8707
8708 static void nf_tables_module_autoload(struct net *net)
8709 {
8710         struct nftables_pernet *nft_net = nft_pernet(net);
8711         struct nft_module_request *req, *next;
8712         LIST_HEAD(module_list);
8713
8714         list_splice_init(&nft_net->module_list, &module_list);
8715         mutex_unlock(&nft_net->commit_mutex);
8716         list_for_each_entry_safe(req, next, &module_list, list) {
8717                 request_module("%s", req->module);
8718                 req->done = true;
8719         }
8720         mutex_lock(&nft_net->commit_mutex);
8721         list_splice(&module_list, &nft_net->module_list);
8722 }
8723
8724 static void nf_tables_abort_release(struct nft_trans *trans)
8725 {
8726         switch (trans->msg_type) {
8727         case NFT_MSG_NEWTABLE:
8728                 nf_tables_table_destroy(&trans->ctx);
8729                 break;
8730         case NFT_MSG_NEWCHAIN:
8731                 nf_tables_chain_destroy(&trans->ctx);
8732                 break;
8733         case NFT_MSG_NEWRULE:
8734                 nf_tables_rule_destroy(&trans->ctx, nft_trans_rule(trans));
8735                 break;
8736         case NFT_MSG_NEWSET:
8737                 nft_set_destroy(&trans->ctx, nft_trans_set(trans));
8738                 break;
8739         case NFT_MSG_NEWSETELEM:
8740                 nft_set_elem_destroy(nft_trans_elem_set(trans),
8741                                      nft_trans_elem(trans).priv, true);
8742                 break;
8743         case NFT_MSG_NEWOBJ:
8744                 nft_obj_destroy(&trans->ctx, nft_trans_obj(trans));
8745                 break;
8746         case NFT_MSG_NEWFLOWTABLE:
8747                 if (nft_trans_flowtable_update(trans))
8748                         nft_flowtable_hooks_destroy(&nft_trans_flowtable_hooks(trans));
8749                 else
8750                         nf_tables_flowtable_destroy(nft_trans_flowtable(trans));
8751                 break;
8752         }
8753         kfree(trans);
8754 }
8755
8756 static int __nf_tables_abort(struct net *net, enum nfnl_abort_action action)
8757 {
8758         struct nftables_pernet *nft_net = nft_pernet(net);
8759         struct nft_trans *trans, *next;
8760         struct nft_trans_elem *te;
8761         struct nft_hook *hook;
8762
8763         if (action == NFNL_ABORT_VALIDATE &&
8764             nf_tables_validate(net) < 0)
8765                 return -EAGAIN;
8766
8767         list_for_each_entry_safe_reverse(trans, next, &nft_net->commit_list,
8768                                          list) {
8769                 switch (trans->msg_type) {
8770                 case NFT_MSG_NEWTABLE:
8771                         if (nft_trans_table_update(trans)) {
8772                                 if (!(trans->ctx.table->flags & __NFT_TABLE_F_UPDATE)) {
8773                                         nft_trans_destroy(trans);
8774                                         break;
8775                                 }
8776                                 if (trans->ctx.table->flags & __NFT_TABLE_F_WAS_DORMANT) {
8777                                         nf_tables_table_disable(net, trans->ctx.table);
8778                                         trans->ctx.table->flags |= NFT_TABLE_F_DORMANT;
8779                                 } else if (trans->ctx.table->flags & __NFT_TABLE_F_WAS_AWAKEN) {
8780                                         trans->ctx.table->flags &= ~NFT_TABLE_F_DORMANT;
8781                                 }
8782                                 trans->ctx.table->flags &= ~__NFT_TABLE_F_UPDATE;
8783                                 nft_trans_destroy(trans);
8784                         } else {
8785                                 list_del_rcu(&trans->ctx.table->list);
8786                         }
8787                         break;
8788                 case NFT_MSG_DELTABLE:
8789                         nft_clear(trans->ctx.net, trans->ctx.table);
8790                         nft_trans_destroy(trans);
8791                         break;
8792                 case NFT_MSG_NEWCHAIN:
8793                         if (nft_trans_chain_update(trans)) {
8794                                 free_percpu(nft_trans_chain_stats(trans));
8795                                 kfree(nft_trans_chain_name(trans));
8796                                 nft_trans_destroy(trans);
8797                         } else {
8798                                 if (nft_chain_is_bound(trans->ctx.chain)) {
8799                                         nft_trans_destroy(trans);
8800                                         break;
8801                                 }
8802                                 trans->ctx.table->use--;
8803                                 nft_chain_del(trans->ctx.chain);
8804                                 nf_tables_unregister_hook(trans->ctx.net,
8805                                                           trans->ctx.table,
8806                                                           trans->ctx.chain);
8807                         }
8808                         break;
8809                 case NFT_MSG_DELCHAIN:
8810                         trans->ctx.table->use++;
8811                         nft_clear(trans->ctx.net, trans->ctx.chain);
8812                         nft_trans_destroy(trans);
8813                         break;
8814                 case NFT_MSG_NEWRULE:
8815                         trans->ctx.chain->use--;
8816                         list_del_rcu(&nft_trans_rule(trans)->list);
8817                         nft_rule_expr_deactivate(&trans->ctx,
8818                                                  nft_trans_rule(trans),
8819                                                  NFT_TRANS_ABORT);
8820                         if (trans->ctx.chain->flags & NFT_CHAIN_HW_OFFLOAD)
8821                                 nft_flow_rule_destroy(nft_trans_flow_rule(trans));
8822                         break;
8823                 case NFT_MSG_DELRULE:
8824                         trans->ctx.chain->use++;
8825                         nft_clear(trans->ctx.net, nft_trans_rule(trans));
8826                         nft_rule_expr_activate(&trans->ctx, nft_trans_rule(trans));
8827                         if (trans->ctx.chain->flags & NFT_CHAIN_HW_OFFLOAD)
8828                                 nft_flow_rule_destroy(nft_trans_flow_rule(trans));
8829
8830                         nft_trans_destroy(trans);
8831                         break;
8832                 case NFT_MSG_NEWSET:
8833                         trans->ctx.table->use--;
8834                         if (nft_trans_set_bound(trans)) {
8835                                 nft_trans_destroy(trans);
8836                                 break;
8837                         }
8838                         list_del_rcu(&nft_trans_set(trans)->list);
8839                         break;
8840                 case NFT_MSG_DELSET:
8841                         trans->ctx.table->use++;
8842                         nft_clear(trans->ctx.net, nft_trans_set(trans));
8843                         nft_trans_destroy(trans);
8844                         break;
8845                 case NFT_MSG_NEWSETELEM:
8846                         if (nft_trans_elem_set_bound(trans)) {
8847                                 nft_trans_destroy(trans);
8848                                 break;
8849                         }
8850                         te = (struct nft_trans_elem *)trans->data;
8851                         nft_setelem_remove(net, te->set, &te->elem);
8852                         if (!nft_setelem_is_catchall(te->set, &te->elem))
8853                                 atomic_dec(&te->set->nelems);
8854                         break;
8855                 case NFT_MSG_DELSETELEM:
8856                         te = (struct nft_trans_elem *)trans->data;
8857
8858                         nft_setelem_data_activate(net, te->set, &te->elem);
8859                         nft_setelem_activate(net, te->set, &te->elem);
8860                         if (!nft_setelem_is_catchall(te->set, &te->elem))
8861                                 te->set->ndeact--;
8862
8863                         nft_trans_destroy(trans);
8864                         break;
8865                 case NFT_MSG_NEWOBJ:
8866                         if (nft_trans_obj_update(trans)) {
8867                                 kfree(nft_trans_obj_newobj(trans));
8868                                 nft_trans_destroy(trans);
8869                         } else {
8870                                 trans->ctx.table->use--;
8871                                 nft_obj_del(nft_trans_obj(trans));
8872                         }
8873                         break;
8874                 case NFT_MSG_DELOBJ:
8875                         trans->ctx.table->use++;
8876                         nft_clear(trans->ctx.net, nft_trans_obj(trans));
8877                         nft_trans_destroy(trans);
8878                         break;
8879                 case NFT_MSG_NEWFLOWTABLE:
8880                         if (nft_trans_flowtable_update(trans)) {
8881                                 nft_unregister_flowtable_net_hooks(net,
8882                                                 &nft_trans_flowtable_hooks(trans));
8883                         } else {
8884                                 trans->ctx.table->use--;
8885                                 list_del_rcu(&nft_trans_flowtable(trans)->list);
8886                                 nft_unregister_flowtable_net_hooks(net,
8887                                                 &nft_trans_flowtable(trans)->hook_list);
8888                         }
8889                         break;
8890                 case NFT_MSG_DELFLOWTABLE:
8891                         if (nft_trans_flowtable_update(trans)) {
8892                                 list_for_each_entry(hook, &nft_trans_flowtable(trans)->hook_list, list)
8893                                         hook->inactive = false;
8894                         } else {
8895                                 trans->ctx.table->use++;
8896                                 nft_clear(trans->ctx.net, nft_trans_flowtable(trans));
8897                         }
8898                         nft_trans_destroy(trans);
8899                         break;
8900                 }
8901         }
8902
8903         synchronize_rcu();
8904
8905         list_for_each_entry_safe_reverse(trans, next,
8906                                          &nft_net->commit_list, list) {
8907                 list_del(&trans->list);
8908                 nf_tables_abort_release(trans);
8909         }
8910
8911         if (action == NFNL_ABORT_AUTOLOAD)
8912                 nf_tables_module_autoload(net);
8913         else
8914                 nf_tables_module_autoload_cleanup(net);
8915
8916         return 0;
8917 }
8918
8919 static void nf_tables_cleanup(struct net *net)
8920 {
8921         nft_validate_state_update(net, NFT_VALIDATE_SKIP);
8922 }
8923
8924 static int nf_tables_abort(struct net *net, struct sk_buff *skb,
8925                            enum nfnl_abort_action action)
8926 {
8927         struct nftables_pernet *nft_net = nft_pernet(net);
8928         int ret = __nf_tables_abort(net, action);
8929
8930         mutex_unlock(&nft_net->commit_mutex);
8931
8932         return ret;
8933 }
8934
8935 static bool nf_tables_valid_genid(struct net *net, u32 genid)
8936 {
8937         struct nftables_pernet *nft_net = nft_pernet(net);
8938         bool genid_ok;
8939
8940         mutex_lock(&nft_net->commit_mutex);
8941
8942         genid_ok = genid == 0 || nft_net->base_seq == genid;
8943         if (!genid_ok)
8944                 mutex_unlock(&nft_net->commit_mutex);
8945
8946         /* else, commit mutex has to be released by commit or abort function */
8947         return genid_ok;
8948 }
8949
8950 static const struct nfnetlink_subsystem nf_tables_subsys = {
8951         .name           = "nf_tables",
8952         .subsys_id      = NFNL_SUBSYS_NFTABLES,
8953         .cb_count       = NFT_MSG_MAX,
8954         .cb             = nf_tables_cb,
8955         .commit         = nf_tables_commit,
8956         .abort          = nf_tables_abort,
8957         .cleanup        = nf_tables_cleanup,
8958         .valid_genid    = nf_tables_valid_genid,
8959         .owner          = THIS_MODULE,
8960 };
8961
8962 int nft_chain_validate_dependency(const struct nft_chain *chain,
8963                                   enum nft_chain_types type)
8964 {
8965         const struct nft_base_chain *basechain;
8966
8967         if (nft_is_base_chain(chain)) {
8968                 basechain = nft_base_chain(chain);
8969                 if (basechain->type->type != type)
8970                         return -EOPNOTSUPP;
8971         }
8972         return 0;
8973 }
8974 EXPORT_SYMBOL_GPL(nft_chain_validate_dependency);
8975
8976 int nft_chain_validate_hooks(const struct nft_chain *chain,
8977                              unsigned int hook_flags)
8978 {
8979         struct nft_base_chain *basechain;
8980
8981         if (nft_is_base_chain(chain)) {
8982                 basechain = nft_base_chain(chain);
8983
8984                 if ((1 << basechain->ops.hooknum) & hook_flags)
8985                         return 0;
8986
8987                 return -EOPNOTSUPP;
8988         }
8989
8990         return 0;
8991 }
8992 EXPORT_SYMBOL_GPL(nft_chain_validate_hooks);
8993
8994 /*
8995  * Loop detection - walk through the ruleset beginning at the destination chain
8996  * of a new jump until either the source chain is reached (loop) or all
8997  * reachable chains have been traversed.
8998  *
8999  * The loop check is performed whenever a new jump verdict is added to an
9000  * expression or verdict map or a verdict map is bound to a new chain.
9001  */
9002
9003 static int nf_tables_check_loops(const struct nft_ctx *ctx,
9004                                  const struct nft_chain *chain);
9005
9006 static int nft_check_loops(const struct nft_ctx *ctx,
9007                            const struct nft_set_ext *ext)
9008 {
9009         const struct nft_data *data;
9010         int ret;
9011
9012         data = nft_set_ext_data(ext);
9013         switch (data->verdict.code) {
9014         case NFT_JUMP:
9015         case NFT_GOTO:
9016                 ret = nf_tables_check_loops(ctx, data->verdict.chain);
9017                 break;
9018         default:
9019                 ret = 0;
9020                 break;
9021         }
9022
9023         return ret;
9024 }
9025
9026 static int nf_tables_loop_check_setelem(const struct nft_ctx *ctx,
9027                                         struct nft_set *set,
9028                                         const struct nft_set_iter *iter,
9029                                         struct nft_set_elem *elem)
9030 {
9031         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
9032
9033         if (nft_set_ext_exists(ext, NFT_SET_EXT_FLAGS) &&
9034             *nft_set_ext_flags(ext) & NFT_SET_ELEM_INTERVAL_END)
9035                 return 0;
9036
9037         return nft_check_loops(ctx, ext);
9038 }
9039
9040 static int nft_set_catchall_loops(const struct nft_ctx *ctx,
9041                                   struct nft_set *set)
9042 {
9043         u8 genmask = nft_genmask_next(ctx->net);
9044         struct nft_set_elem_catchall *catchall;
9045         struct nft_set_ext *ext;
9046         int ret = 0;
9047
9048         list_for_each_entry_rcu(catchall, &set->catchall_list, list) {
9049                 ext = nft_set_elem_ext(set, catchall->elem);
9050                 if (!nft_set_elem_active(ext, genmask))
9051                         continue;
9052
9053                 ret = nft_check_loops(ctx, ext);
9054                 if (ret < 0)
9055                         return ret;
9056         }
9057
9058         return ret;
9059 }
9060
9061 static int nf_tables_check_loops(const struct nft_ctx *ctx,
9062                                  const struct nft_chain *chain)
9063 {
9064         const struct nft_rule *rule;
9065         const struct nft_expr *expr, *last;
9066         struct nft_set *set;
9067         struct nft_set_binding *binding;
9068         struct nft_set_iter iter;
9069
9070         if (ctx->chain == chain)
9071                 return -ELOOP;
9072
9073         list_for_each_entry(rule, &chain->rules, list) {
9074                 nft_rule_for_each_expr(expr, last, rule) {
9075                         struct nft_immediate_expr *priv;
9076                         const struct nft_data *data;
9077                         int err;
9078
9079                         if (strcmp(expr->ops->type->name, "immediate"))
9080                                 continue;
9081
9082                         priv = nft_expr_priv(expr);
9083                         if (priv->dreg != NFT_REG_VERDICT)
9084                                 continue;
9085
9086                         data = &priv->data;
9087                         switch (data->verdict.code) {
9088                         case NFT_JUMP:
9089                         case NFT_GOTO:
9090                                 err = nf_tables_check_loops(ctx,
9091                                                         data->verdict.chain);
9092                                 if (err < 0)
9093                                         return err;
9094                                 break;
9095                         default:
9096                                 break;
9097                         }
9098                 }
9099         }
9100
9101         list_for_each_entry(set, &ctx->table->sets, list) {
9102                 if (!nft_is_active_next(ctx->net, set))
9103                         continue;
9104                 if (!(set->flags & NFT_SET_MAP) ||
9105                     set->dtype != NFT_DATA_VERDICT)
9106                         continue;
9107
9108                 list_for_each_entry(binding, &set->bindings, list) {
9109                         if (!(binding->flags & NFT_SET_MAP) ||
9110                             binding->chain != chain)
9111                                 continue;
9112
9113                         iter.genmask    = nft_genmask_next(ctx->net);
9114                         iter.skip       = 0;
9115                         iter.count      = 0;
9116                         iter.err        = 0;
9117                         iter.fn         = nf_tables_loop_check_setelem;
9118
9119                         set->ops->walk(ctx, set, &iter);
9120                         if (!iter.err)
9121                                 iter.err = nft_set_catchall_loops(ctx, set);
9122
9123                         if (iter.err < 0)
9124                                 return iter.err;
9125                 }
9126         }
9127
9128         return 0;
9129 }
9130
9131 /**
9132  *      nft_parse_u32_check - fetch u32 attribute and check for maximum value
9133  *
9134  *      @attr: netlink attribute to fetch value from
9135  *      @max: maximum value to be stored in dest
9136  *      @dest: pointer to the variable
9137  *
9138  *      Parse, check and store a given u32 netlink attribute into variable.
9139  *      This function returns -ERANGE if the value goes over maximum value.
9140  *      Otherwise a 0 is returned and the attribute value is stored in the
9141  *      destination variable.
9142  */
9143 int nft_parse_u32_check(const struct nlattr *attr, int max, u32 *dest)
9144 {
9145         u32 val;
9146
9147         val = ntohl(nla_get_be32(attr));
9148         if (val > max)
9149                 return -ERANGE;
9150
9151         *dest = val;
9152         return 0;
9153 }
9154 EXPORT_SYMBOL_GPL(nft_parse_u32_check);
9155
9156 static unsigned int nft_parse_register(const struct nlattr *attr)
9157 {
9158         unsigned int reg;
9159
9160         reg = ntohl(nla_get_be32(attr));
9161         switch (reg) {
9162         case NFT_REG_VERDICT...NFT_REG_4:
9163                 return reg * NFT_REG_SIZE / NFT_REG32_SIZE;
9164         default:
9165                 return reg + NFT_REG_SIZE / NFT_REG32_SIZE - NFT_REG32_00;
9166         }
9167 }
9168
9169 /**
9170  *      nft_dump_register - dump a register value to a netlink attribute
9171  *
9172  *      @skb: socket buffer
9173  *      @attr: attribute number
9174  *      @reg: register number
9175  *
9176  *      Construct a netlink attribute containing the register number. For
9177  *      compatibility reasons, register numbers being a multiple of 4 are
9178  *      translated to the corresponding 128 bit register numbers.
9179  */
9180 int nft_dump_register(struct sk_buff *skb, unsigned int attr, unsigned int reg)
9181 {
9182         if (reg % (NFT_REG_SIZE / NFT_REG32_SIZE) == 0)
9183                 reg = reg / (NFT_REG_SIZE / NFT_REG32_SIZE);
9184         else
9185                 reg = reg - NFT_REG_SIZE / NFT_REG32_SIZE + NFT_REG32_00;
9186
9187         return nla_put_be32(skb, attr, htonl(reg));
9188 }
9189 EXPORT_SYMBOL_GPL(nft_dump_register);
9190
9191 static int nft_validate_register_load(enum nft_registers reg, unsigned int len)
9192 {
9193         if (reg < NFT_REG_1 * NFT_REG_SIZE / NFT_REG32_SIZE)
9194                 return -EINVAL;
9195         if (len == 0)
9196                 return -EINVAL;
9197         if (reg * NFT_REG32_SIZE + len > sizeof_field(struct nft_regs, data))
9198                 return -ERANGE;
9199
9200         return 0;
9201 }
9202
9203 int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len)
9204 {
9205         u32 reg;
9206         int err;
9207
9208         reg = nft_parse_register(attr);
9209         err = nft_validate_register_load(reg, len);
9210         if (err < 0)
9211                 return err;
9212
9213         *sreg = reg;
9214         return 0;
9215 }
9216 EXPORT_SYMBOL_GPL(nft_parse_register_load);
9217
9218 static int nft_validate_register_store(const struct nft_ctx *ctx,
9219                                        enum nft_registers reg,
9220                                        const struct nft_data *data,
9221                                        enum nft_data_types type,
9222                                        unsigned int len)
9223 {
9224         int err;
9225
9226         switch (reg) {
9227         case NFT_REG_VERDICT:
9228                 if (type != NFT_DATA_VERDICT)
9229                         return -EINVAL;
9230
9231                 if (data != NULL &&
9232                     (data->verdict.code == NFT_GOTO ||
9233                      data->verdict.code == NFT_JUMP)) {
9234                         err = nf_tables_check_loops(ctx, data->verdict.chain);
9235                         if (err < 0)
9236                                 return err;
9237                 }
9238
9239                 return 0;
9240         default:
9241                 if (reg < NFT_REG_1 * NFT_REG_SIZE / NFT_REG32_SIZE)
9242                         return -EINVAL;
9243                 if (len == 0)
9244                         return -EINVAL;
9245                 if (reg * NFT_REG32_SIZE + len >
9246                     sizeof_field(struct nft_regs, data))
9247                         return -ERANGE;
9248
9249                 if (data != NULL && type != NFT_DATA_VALUE)
9250                         return -EINVAL;
9251                 return 0;
9252         }
9253 }
9254
9255 int nft_parse_register_store(const struct nft_ctx *ctx,
9256                              const struct nlattr *attr, u8 *dreg,
9257                              const struct nft_data *data,
9258                              enum nft_data_types type, unsigned int len)
9259 {
9260         int err;
9261         u32 reg;
9262
9263         reg = nft_parse_register(attr);
9264         err = nft_validate_register_store(ctx, reg, data, type, len);
9265         if (err < 0)
9266                 return err;
9267
9268         *dreg = reg;
9269         return 0;
9270 }
9271 EXPORT_SYMBOL_GPL(nft_parse_register_store);
9272
9273 static const struct nla_policy nft_verdict_policy[NFTA_VERDICT_MAX + 1] = {
9274         [NFTA_VERDICT_CODE]     = { .type = NLA_U32 },
9275         [NFTA_VERDICT_CHAIN]    = { .type = NLA_STRING,
9276                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
9277         [NFTA_VERDICT_CHAIN_ID] = { .type = NLA_U32 },
9278 };
9279
9280 static int nft_verdict_init(const struct nft_ctx *ctx, struct nft_data *data,
9281                             struct nft_data_desc *desc, const struct nlattr *nla)
9282 {
9283         u8 genmask = nft_genmask_next(ctx->net);
9284         struct nlattr *tb[NFTA_VERDICT_MAX + 1];
9285         struct nft_chain *chain;
9286         int err;
9287
9288         err = nla_parse_nested_deprecated(tb, NFTA_VERDICT_MAX, nla,
9289                                           nft_verdict_policy, NULL);
9290         if (err < 0)
9291                 return err;
9292
9293         if (!tb[NFTA_VERDICT_CODE])
9294                 return -EINVAL;
9295         data->verdict.code = ntohl(nla_get_be32(tb[NFTA_VERDICT_CODE]));
9296
9297         switch (data->verdict.code) {
9298         default:
9299                 switch (data->verdict.code & NF_VERDICT_MASK) {
9300                 case NF_ACCEPT:
9301                 case NF_DROP:
9302                 case NF_QUEUE:
9303                         break;
9304                 default:
9305                         return -EINVAL;
9306                 }
9307                 fallthrough;
9308         case NFT_CONTINUE:
9309         case NFT_BREAK:
9310         case NFT_RETURN:
9311                 break;
9312         case NFT_JUMP:
9313         case NFT_GOTO:
9314                 if (tb[NFTA_VERDICT_CHAIN]) {
9315                         chain = nft_chain_lookup(ctx->net, ctx->table,
9316                                                  tb[NFTA_VERDICT_CHAIN],
9317                                                  genmask);
9318                 } else if (tb[NFTA_VERDICT_CHAIN_ID]) {
9319                         chain = nft_chain_lookup_byid(ctx->net,
9320                                                       tb[NFTA_VERDICT_CHAIN_ID]);
9321                         if (IS_ERR(chain))
9322                                 return PTR_ERR(chain);
9323                 } else {
9324                         return -EINVAL;
9325                 }
9326
9327                 if (IS_ERR(chain))
9328                         return PTR_ERR(chain);
9329                 if (nft_is_base_chain(chain))
9330                         return -EOPNOTSUPP;
9331
9332                 chain->use++;
9333                 data->verdict.chain = chain;
9334                 break;
9335         }
9336
9337         desc->len = sizeof(data->verdict);
9338         desc->type = NFT_DATA_VERDICT;
9339         return 0;
9340 }
9341
9342 static void nft_verdict_uninit(const struct nft_data *data)
9343 {
9344         struct nft_chain *chain;
9345         struct nft_rule *rule;
9346
9347         switch (data->verdict.code) {
9348         case NFT_JUMP:
9349         case NFT_GOTO:
9350                 chain = data->verdict.chain;
9351                 chain->use--;
9352
9353                 if (!nft_chain_is_bound(chain))
9354                         break;
9355
9356                 chain->table->use--;
9357                 list_for_each_entry(rule, &chain->rules, list)
9358                         chain->use--;
9359
9360                 nft_chain_del(chain);
9361                 break;
9362         }
9363 }
9364
9365 int nft_verdict_dump(struct sk_buff *skb, int type, const struct nft_verdict *v)
9366 {
9367         struct nlattr *nest;
9368
9369         nest = nla_nest_start_noflag(skb, type);
9370         if (!nest)
9371                 goto nla_put_failure;
9372
9373         if (nla_put_be32(skb, NFTA_VERDICT_CODE, htonl(v->code)))
9374                 goto nla_put_failure;
9375
9376         switch (v->code) {
9377         case NFT_JUMP:
9378         case NFT_GOTO:
9379                 if (nla_put_string(skb, NFTA_VERDICT_CHAIN,
9380                                    v->chain->name))
9381                         goto nla_put_failure;
9382         }
9383         nla_nest_end(skb, nest);
9384         return 0;
9385
9386 nla_put_failure:
9387         return -1;
9388 }
9389
9390 static int nft_value_init(const struct nft_ctx *ctx,
9391                           struct nft_data *data, unsigned int size,
9392                           struct nft_data_desc *desc, const struct nlattr *nla)
9393 {
9394         unsigned int len;
9395
9396         len = nla_len(nla);
9397         if (len == 0)
9398                 return -EINVAL;
9399         if (len > size)
9400                 return -EOVERFLOW;
9401
9402         nla_memcpy(data->data, nla, len);
9403         desc->type = NFT_DATA_VALUE;
9404         desc->len  = len;
9405         return 0;
9406 }
9407
9408 static int nft_value_dump(struct sk_buff *skb, const struct nft_data *data,
9409                           unsigned int len)
9410 {
9411         return nla_put(skb, NFTA_DATA_VALUE, len, data->data);
9412 }
9413
9414 static const struct nla_policy nft_data_policy[NFTA_DATA_MAX + 1] = {
9415         [NFTA_DATA_VALUE]       = { .type = NLA_BINARY },
9416         [NFTA_DATA_VERDICT]     = { .type = NLA_NESTED },
9417 };
9418
9419 /**
9420  *      nft_data_init - parse nf_tables data netlink attributes
9421  *
9422  *      @ctx: context of the expression using the data
9423  *      @data: destination struct nft_data
9424  *      @size: maximum data length
9425  *      @desc: data description
9426  *      @nla: netlink attribute containing data
9427  *
9428  *      Parse the netlink data attributes and initialize a struct nft_data.
9429  *      The type and length of data are returned in the data description.
9430  *
9431  *      The caller can indicate that it only wants to accept data of type
9432  *      NFT_DATA_VALUE by passing NULL for the ctx argument.
9433  */
9434 int nft_data_init(const struct nft_ctx *ctx,
9435                   struct nft_data *data, unsigned int size,
9436                   struct nft_data_desc *desc, const struct nlattr *nla)
9437 {
9438         struct nlattr *tb[NFTA_DATA_MAX + 1];
9439         int err;
9440
9441         err = nla_parse_nested_deprecated(tb, NFTA_DATA_MAX, nla,
9442                                           nft_data_policy, NULL);
9443         if (err < 0)
9444                 return err;
9445
9446         if (tb[NFTA_DATA_VALUE])
9447                 return nft_value_init(ctx, data, size, desc,
9448                                       tb[NFTA_DATA_VALUE]);
9449         if (tb[NFTA_DATA_VERDICT] && ctx != NULL)
9450                 return nft_verdict_init(ctx, data, desc, tb[NFTA_DATA_VERDICT]);
9451         return -EINVAL;
9452 }
9453 EXPORT_SYMBOL_GPL(nft_data_init);
9454
9455 /**
9456  *      nft_data_release - release a nft_data item
9457  *
9458  *      @data: struct nft_data to release
9459  *      @type: type of data
9460  *
9461  *      Release a nft_data item. NFT_DATA_VALUE types can be silently discarded,
9462  *      all others need to be released by calling this function.
9463  */
9464 void nft_data_release(const struct nft_data *data, enum nft_data_types type)
9465 {
9466         if (type < NFT_DATA_VERDICT)
9467                 return;
9468         switch (type) {
9469         case NFT_DATA_VERDICT:
9470                 return nft_verdict_uninit(data);
9471         default:
9472                 WARN_ON(1);
9473         }
9474 }
9475 EXPORT_SYMBOL_GPL(nft_data_release);
9476
9477 int nft_data_dump(struct sk_buff *skb, int attr, const struct nft_data *data,
9478                   enum nft_data_types type, unsigned int len)
9479 {
9480         struct nlattr *nest;
9481         int err;
9482
9483         nest = nla_nest_start_noflag(skb, attr);
9484         if (nest == NULL)
9485                 return -1;
9486
9487         switch (type) {
9488         case NFT_DATA_VALUE:
9489                 err = nft_value_dump(skb, data, len);
9490                 break;
9491         case NFT_DATA_VERDICT:
9492                 err = nft_verdict_dump(skb, NFTA_DATA_VERDICT, &data->verdict);
9493                 break;
9494         default:
9495                 err = -EINVAL;
9496                 WARN_ON(1);
9497         }
9498
9499         nla_nest_end(skb, nest);
9500         return err;
9501 }
9502 EXPORT_SYMBOL_GPL(nft_data_dump);
9503
9504 int __nft_release_basechain(struct nft_ctx *ctx)
9505 {
9506         struct nft_rule *rule, *nr;
9507
9508         if (WARN_ON(!nft_is_base_chain(ctx->chain)))
9509                 return 0;
9510
9511         nf_tables_unregister_hook(ctx->net, ctx->chain->table, ctx->chain);
9512         list_for_each_entry_safe(rule, nr, &ctx->chain->rules, list) {
9513                 list_del(&rule->list);
9514                 ctx->chain->use--;
9515                 nf_tables_rule_release(ctx, rule);
9516         }
9517         nft_chain_del(ctx->chain);
9518         ctx->table->use--;
9519         nf_tables_chain_destroy(ctx);
9520
9521         return 0;
9522 }
9523 EXPORT_SYMBOL_GPL(__nft_release_basechain);
9524
9525 static void __nft_release_hook(struct net *net, struct nft_table *table)
9526 {
9527         struct nft_chain *chain;
9528
9529         list_for_each_entry(chain, &table->chains, list)
9530                 nf_tables_unregister_hook(net, table, chain);
9531 }
9532
9533 static void __nft_release_hooks(struct net *net)
9534 {
9535         struct nftables_pernet *nft_net = nft_pernet(net);
9536         struct nft_table *table;
9537
9538         list_for_each_entry(table, &nft_net->tables, list) {
9539                 if (nft_table_has_owner(table))
9540                         continue;
9541
9542                 __nft_release_hook(net, table);
9543         }
9544 }
9545
9546 static void __nft_release_table(struct net *net, struct nft_table *table)
9547 {
9548         struct nft_flowtable *flowtable, *nf;
9549         struct nft_chain *chain, *nc;
9550         struct nft_object *obj, *ne;
9551         struct nft_rule *rule, *nr;
9552         struct nft_set *set, *ns;
9553         struct nft_ctx ctx = {
9554                 .net    = net,
9555                 .family = NFPROTO_NETDEV,
9556         };
9557
9558         ctx.family = table->family;
9559         ctx.table = table;
9560         list_for_each_entry(chain, &table->chains, list) {
9561                 ctx.chain = chain;
9562                 list_for_each_entry_safe(rule, nr, &chain->rules, list) {
9563                         list_del(&rule->list);
9564                         chain->use--;
9565                         nf_tables_rule_release(&ctx, rule);
9566                 }
9567         }
9568         list_for_each_entry_safe(flowtable, nf, &table->flowtables, list) {
9569                 list_del(&flowtable->list);
9570                 table->use--;
9571                 nf_tables_flowtable_destroy(flowtable);
9572         }
9573         list_for_each_entry_safe(set, ns, &table->sets, list) {
9574                 list_del(&set->list);
9575                 table->use--;
9576                 nft_set_destroy(&ctx, set);
9577         }
9578         list_for_each_entry_safe(obj, ne, &table->objects, list) {
9579                 nft_obj_del(obj);
9580                 table->use--;
9581                 nft_obj_destroy(&ctx, obj);
9582         }
9583         list_for_each_entry_safe(chain, nc, &table->chains, list) {
9584                 ctx.chain = chain;
9585                 nft_chain_del(chain);
9586                 table->use--;
9587                 nf_tables_chain_destroy(&ctx);
9588         }
9589         list_del(&table->list);
9590         nf_tables_table_destroy(&ctx);
9591 }
9592
9593 static void __nft_release_tables(struct net *net)
9594 {
9595         struct nftables_pernet *nft_net = nft_pernet(net);
9596         struct nft_table *table, *nt;
9597
9598         list_for_each_entry_safe(table, nt, &nft_net->tables, list) {
9599                 if (nft_table_has_owner(table))
9600                         continue;
9601
9602                 __nft_release_table(net, table);
9603         }
9604 }
9605
9606 static int nft_rcv_nl_event(struct notifier_block *this, unsigned long event,
9607                             void *ptr)
9608 {
9609         struct nftables_pernet *nft_net;
9610         struct netlink_notify *n = ptr;
9611         struct nft_table *table, *nt;
9612         struct net *net = n->net;
9613         bool release = false;
9614
9615         if (event != NETLINK_URELEASE || n->protocol != NETLINK_NETFILTER)
9616                 return NOTIFY_DONE;
9617
9618         nft_net = nft_pernet(net);
9619         mutex_lock(&nft_net->commit_mutex);
9620         list_for_each_entry(table, &nft_net->tables, list) {
9621                 if (nft_table_has_owner(table) &&
9622                     n->portid == table->nlpid) {
9623                         __nft_release_hook(net, table);
9624                         release = true;
9625                 }
9626         }
9627         if (release) {
9628                 synchronize_rcu();
9629                 list_for_each_entry_safe(table, nt, &nft_net->tables, list) {
9630                         if (nft_table_has_owner(table) &&
9631                             n->portid == table->nlpid)
9632                                 __nft_release_table(net, table);
9633                 }
9634         }
9635         mutex_unlock(&nft_net->commit_mutex);
9636
9637         return NOTIFY_DONE;
9638 }
9639
9640 static struct notifier_block nft_nl_notifier = {
9641         .notifier_call  = nft_rcv_nl_event,
9642 };
9643
9644 static int __net_init nf_tables_init_net(struct net *net)
9645 {
9646         struct nftables_pernet *nft_net = nft_pernet(net);
9647
9648         INIT_LIST_HEAD(&nft_net->tables);
9649         INIT_LIST_HEAD(&nft_net->commit_list);
9650         INIT_LIST_HEAD(&nft_net->module_list);
9651         INIT_LIST_HEAD(&nft_net->notify_list);
9652         mutex_init(&nft_net->commit_mutex);
9653         nft_net->base_seq = 1;
9654         nft_net->validate_state = NFT_VALIDATE_SKIP;
9655
9656         return 0;
9657 }
9658
9659 static void __net_exit nf_tables_pre_exit_net(struct net *net)
9660 {
9661         __nft_release_hooks(net);
9662 }
9663
9664 static void __net_exit nf_tables_exit_net(struct net *net)
9665 {
9666         struct nftables_pernet *nft_net = nft_pernet(net);
9667
9668         mutex_lock(&nft_net->commit_mutex);
9669         if (!list_empty(&nft_net->commit_list))
9670                 __nf_tables_abort(net, NFNL_ABORT_NONE);
9671         __nft_release_tables(net);
9672         mutex_unlock(&nft_net->commit_mutex);
9673         WARN_ON_ONCE(!list_empty(&nft_net->tables));
9674         WARN_ON_ONCE(!list_empty(&nft_net->module_list));
9675         WARN_ON_ONCE(!list_empty(&nft_net->notify_list));
9676 }
9677
9678 static struct pernet_operations nf_tables_net_ops = {
9679         .init           = nf_tables_init_net,
9680         .pre_exit       = nf_tables_pre_exit_net,
9681         .exit           = nf_tables_exit_net,
9682         .id             = &nf_tables_net_id,
9683         .size           = sizeof(struct nftables_pernet),
9684 };
9685
9686 static int __init nf_tables_module_init(void)
9687 {
9688         int err;
9689
9690         err = register_pernet_subsys(&nf_tables_net_ops);
9691         if (err < 0)
9692                 return err;
9693
9694         err = nft_chain_filter_init();
9695         if (err < 0)
9696                 goto err_chain_filter;
9697
9698         err = nf_tables_core_module_init();
9699         if (err < 0)
9700                 goto err_core_module;
9701
9702         err = register_netdevice_notifier(&nf_tables_flowtable_notifier);
9703         if (err < 0)
9704                 goto err_netdev_notifier;
9705
9706         err = rhltable_init(&nft_objname_ht, &nft_objname_ht_params);
9707         if (err < 0)
9708                 goto err_rht_objname;
9709
9710         err = nft_offload_init();
9711         if (err < 0)
9712                 goto err_offload;
9713
9714         err = netlink_register_notifier(&nft_nl_notifier);
9715         if (err < 0)
9716                 goto err_netlink_notifier;
9717
9718         /* must be last */
9719         err = nfnetlink_subsys_register(&nf_tables_subsys);
9720         if (err < 0)
9721                 goto err_nfnl_subsys;
9722
9723         nft_chain_route_init();
9724
9725         return err;
9726
9727 err_nfnl_subsys:
9728         netlink_unregister_notifier(&nft_nl_notifier);
9729 err_netlink_notifier:
9730         nft_offload_exit();
9731 err_offload:
9732         rhltable_destroy(&nft_objname_ht);
9733 err_rht_objname:
9734         unregister_netdevice_notifier(&nf_tables_flowtable_notifier);
9735 err_netdev_notifier:
9736         nf_tables_core_module_exit();
9737 err_core_module:
9738         nft_chain_filter_fini();
9739 err_chain_filter:
9740         unregister_pernet_subsys(&nf_tables_net_ops);
9741         return err;
9742 }
9743
9744 static void __exit nf_tables_module_exit(void)
9745 {
9746         nfnetlink_subsys_unregister(&nf_tables_subsys);
9747         netlink_unregister_notifier(&nft_nl_notifier);
9748         nft_offload_exit();
9749         unregister_netdevice_notifier(&nf_tables_flowtable_notifier);
9750         nft_chain_filter_fini();
9751         nft_chain_route_fini();
9752         unregister_pernet_subsys(&nf_tables_net_ops);
9753         cancel_work_sync(&trans_destroy_work);
9754         rcu_barrier();
9755         rhltable_destroy(&nft_objname_ht);
9756         nf_tables_core_module_exit();
9757 }
9758
9759 module_init(nf_tables_module_init);
9760 module_exit(nf_tables_module_exit);
9761
9762 MODULE_LICENSE("GPL");
9763 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
9764 MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_NFTABLES);