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