git.itanic.dy.fi Git - linux-stable/blob - net/netfilter/nf_tables_api.c

   1 /*
   2  * Copyright (c) 2007-2009 Patrick McHardy <kaber@trash.net>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * Development of this code funded by Astaro AG (http://www.astaro.com/)
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 #include <linux/list.h>
  14 #include <linux/skbuff.h>
  15 #include <linux/netlink.h>
  16 #include <linux/vmalloc.h>
  17 #include <linux/netfilter.h>
  18 #include <linux/netfilter/nfnetlink.h>
  19 #include <linux/netfilter/nf_tables.h>
  20 #include <net/netfilter/nf_tables_core.h>
  21 #include <net/netfilter/nf_tables.h>
  22 #include <net/net_namespace.h>
  23 #include <net/sock.h>
  24
  25 static LIST_HEAD(nf_tables_expressions);
  26 static LIST_HEAD(nf_tables_objects);
  27
  28 /**
  29  *      nft_register_afinfo - register nf_tables address family info
  30  *
  31  *      @afi: address family info to register
  32  *
  33  *      Register the address family for use with nf_tables. Returns zero on
  34  *      success or a negative errno code otherwise.
  35  */
  36 int nft_register_afinfo(struct net *net, struct nft_af_info *afi)
  37 {
  38         INIT_LIST_HEAD(&afi->tables);
  39         nfnl_lock(NFNL_SUBSYS_NFTABLES);
  40         list_add_tail_rcu(&afi->list, &net->nft.af_info);
  41         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
  42         return 0;
  43 }
  44 EXPORT_SYMBOL_GPL(nft_register_afinfo);
  45
  46 static void __nft_release_afinfo(struct net *net, struct nft_af_info *afi);
  47
  48 /**
  49  *      nft_unregister_afinfo - unregister nf_tables address family info
  50  *
  51  *      @afi: address family info to unregister
  52  *
  53  *      Unregister the address family for use with nf_tables.
  54  */
  55 void nft_unregister_afinfo(struct net *net, struct nft_af_info *afi)
  56 {
  57         nfnl_lock(NFNL_SUBSYS_NFTABLES);
  58         __nft_release_afinfo(net, afi);
  59         list_del_rcu(&afi->list);
  60         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
  61 }
  62 EXPORT_SYMBOL_GPL(nft_unregister_afinfo);
  63
  64 static struct nft_af_info *nft_afinfo_lookup(struct net *net, int family)
  65 {
  66         struct nft_af_info *afi;
  67
  68         list_for_each_entry(afi, &net->nft.af_info, list) {
  69                 if (afi->family == family)
  70                         return afi;
  71         }
  72         return NULL;
  73 }
  74
  75 static struct nft_af_info *
  76 nf_tables_afinfo_lookup(struct net *net, int family, bool autoload)
  77 {
  78         struct nft_af_info *afi;
  79
  80         afi = nft_afinfo_lookup(net, family);
  81         if (afi != NULL)
  82                 return afi;
  83 #ifdef CONFIG_MODULES
  84         if (autoload) {
  85                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
  86                 request_module("nft-afinfo-%u", family);
  87                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
  88                 afi = nft_afinfo_lookup(net, family);
  89                 if (afi != NULL)
  90                         return ERR_PTR(-EAGAIN);
  91         }
  92 #endif
  93         return ERR_PTR(-EAFNOSUPPORT);
  94 }
  95
  96 static void nft_ctx_init(struct nft_ctx *ctx,
  97                          struct net *net,
  98                          const struct sk_buff *skb,
  99                          const struct nlmsghdr *nlh,
 100                          struct nft_af_info *afi,
 101                          struct nft_table *table,
 102                          struct nft_chain *chain,
 103                          const struct nlattr * const *nla)
 104 {
 105         ctx->net        = net;
 106         ctx->afi        = afi;
 107         ctx->table      = table;
 108         ctx->chain      = chain;
 109         ctx->nla        = nla;
 110         ctx->portid     = NETLINK_CB(skb).portid;
 111         ctx->report     = nlmsg_report(nlh);
 112         ctx->seq        = nlh->nlmsg_seq;
 113 }
 114
 115 static struct nft_trans *nft_trans_alloc_gfp(const struct nft_ctx *ctx,
 116                                              int msg_type, u32 size, gfp_t gfp)
 117 {
 118         struct nft_trans *trans;
 119
 120         trans = kzalloc(sizeof(struct nft_trans) + size, gfp);
 121         if (trans == NULL)
 122                 return NULL;
 123
 124         INIT_LIST_HEAD(&trans->list);
 125         trans->msg_type = msg_type;
 126         trans->ctx      = *ctx;
 127
 128         return trans;
 129 }
 130
 131 static struct nft_trans *nft_trans_alloc(const struct nft_ctx *ctx,
 132                                          int msg_type, u32 size)
 133 {
 134         return nft_trans_alloc_gfp(ctx, msg_type, size, GFP_KERNEL);
 135 }
 136
 137 static void nft_trans_destroy(struct nft_trans *trans)
 138 {
 139         list_del(&trans->list);
 140         kfree(trans);
 141 }
 142
 143 static void nft_set_trans_bind(const struct nft_ctx *ctx, struct nft_set *set)
 144 {
 145         struct net *net = ctx->net;
 146         struct nft_trans *trans;
 147
 148         if (!(set->flags & NFT_SET_ANONYMOUS))
 149                 return;
 150
 151         list_for_each_entry_reverse(trans, &net->nft.commit_list, list) {
 152                 switch (trans->msg_type) {
 153                 case NFT_MSG_NEWSET:
 154                         if (nft_trans_set(trans) == set)
 155                                 nft_trans_set_bound(trans) = true;
 156                         break;
 157                 case NFT_MSG_NEWSETELEM:
 158                         if (nft_trans_elem_set(trans) == set)
 159                                 nft_trans_elem_set_bound(trans) = true;
 160                         break;
 161                 }
 162         }
 163 }
 164
 165 static int nf_tables_register_hooks(struct net *net,
 166                                     const struct nft_table *table,
 167                                     struct nft_chain *chain,
 168                                     unsigned int hook_nops)
 169 {
 170         if (table->flags & NFT_TABLE_F_DORMANT ||
 171             !nft_is_base_chain(chain))
 172                 return 0;
 173
 174         return nf_register_net_hooks(net, nft_base_chain(chain)->ops,
 175                                      hook_nops);
 176 }
 177
 178 static void nf_tables_unregister_hooks(struct net *net,
 179                                        const struct nft_table *table,
 180                                        struct nft_chain *chain,
 181                                        unsigned int hook_nops)
 182 {
 183         if (table->flags & NFT_TABLE_F_DORMANT ||
 184             !nft_is_base_chain(chain))
 185                 return;
 186
 187         nf_unregister_net_hooks(net, nft_base_chain(chain)->ops, hook_nops);
 188 }
 189
 190 static int nft_trans_table_add(struct nft_ctx *ctx, int msg_type)
 191 {
 192         struct nft_trans *trans;
 193
 194         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_table));
 195         if (trans == NULL)
 196                 return -ENOMEM;
 197
 198         if (msg_type == NFT_MSG_NEWTABLE)
 199                 nft_activate_next(ctx->net, ctx->table);
 200
 201         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
 202         return 0;
 203 }
 204
 205 static int nft_deltable(struct nft_ctx *ctx)
 206 {
 207         int err;
 208
 209         err = nft_trans_table_add(ctx, NFT_MSG_DELTABLE);
 210         if (err < 0)
 211                 return err;
 212
 213         nft_deactivate_next(ctx->net, ctx->table);
 214         return err;
 215 }
 216
 217 static int nft_trans_chain_add(struct nft_ctx *ctx, int msg_type)
 218 {
 219         struct nft_trans *trans;
 220
 221         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_chain));
 222         if (trans == NULL)
 223                 return -ENOMEM;
 224
 225         if (msg_type == NFT_MSG_NEWCHAIN)
 226                 nft_activate_next(ctx->net, ctx->chain);
 227
 228         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
 229         return 0;
 230 }
 231
 232 static int nft_delchain(struct nft_ctx *ctx)
 233 {
 234         int err;
 235
 236         err = nft_trans_chain_add(ctx, NFT_MSG_DELCHAIN);
 237         if (err < 0)
 238                 return err;
 239
 240         ctx->table->use--;
 241         nft_deactivate_next(ctx->net, ctx->chain);
 242
 243         return err;
 244 }
 245
 246 static void nft_rule_expr_activate(const struct nft_ctx *ctx,
 247                                    struct nft_rule *rule)
 248 {
 249         struct nft_expr *expr;
 250
 251         expr = nft_expr_first(rule);
 252         while (expr != nft_expr_last(rule) && expr->ops) {
 253                 if (expr->ops->activate)
 254                         expr->ops->activate(ctx, expr);
 255
 256                 expr = nft_expr_next(expr);
 257         }
 258 }
 259
 260 static void nft_rule_expr_deactivate(const struct nft_ctx *ctx,
 261                                      struct nft_rule *rule,
 262                                      enum nft_trans_phase phase)
 263 {
 264         struct nft_expr *expr;
 265
 266         expr = nft_expr_first(rule);
 267         while (expr != nft_expr_last(rule) && expr->ops) {
 268                 if (expr->ops->deactivate)
 269                         expr->ops->deactivate(ctx, expr, phase);
 270
 271                 expr = nft_expr_next(expr);
 272         }
 273 }
 274
 275 static int
 276 nf_tables_delrule_deactivate(struct nft_ctx *ctx, struct nft_rule *rule)
 277 {
 278         /* You cannot delete the same rule twice */
 279         if (nft_is_active_next(ctx->net, rule)) {
 280                 nft_deactivate_next(ctx->net, rule);
 281                 ctx->chain->use--;
 282                 return 0;
 283         }
 284         return -ENOENT;
 285 }
 286
 287 static struct nft_trans *nft_trans_rule_add(struct nft_ctx *ctx, int msg_type,
 288                                             struct nft_rule *rule)
 289 {
 290         struct nft_trans *trans;
 291
 292         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_rule));
 293         if (trans == NULL)
 294                 return NULL;
 295
 296         if (msg_type == NFT_MSG_NEWRULE && ctx->nla[NFTA_RULE_ID] != NULL) {
 297                 nft_trans_rule_id(trans) =
 298                         ntohl(nla_get_be32(ctx->nla[NFTA_RULE_ID]));
 299         }
 300         nft_trans_rule(trans) = rule;
 301         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
 302
 303         return trans;
 304 }
 305
 306 static int nft_delrule(struct nft_ctx *ctx, struct nft_rule *rule)
 307 {
 308         struct nft_trans *trans;
 309         int err;
 310
 311         trans = nft_trans_rule_add(ctx, NFT_MSG_DELRULE, rule);
 312         if (trans == NULL)
 313                 return -ENOMEM;
 314
 315         err = nf_tables_delrule_deactivate(ctx, rule);
 316         if (err < 0) {
 317                 nft_trans_destroy(trans);
 318                 return err;
 319         }
 320         nft_rule_expr_deactivate(ctx, rule, NFT_TRANS_PREPARE);
 321
 322         return 0;
 323 }
 324
 325 static int nft_delrule_by_chain(struct nft_ctx *ctx)
 326 {
 327         struct nft_rule *rule;
 328         int err;
 329
 330         list_for_each_entry(rule, &ctx->chain->rules, list) {
 331                 if (!nft_is_active_next(ctx->net, rule))
 332                         continue;
 333
 334                 err = nft_delrule(ctx, rule);
 335                 if (err < 0)
 336                         return err;
 337         }
 338         return 0;
 339 }
 340
 341 static int nft_trans_set_add(const struct nft_ctx *ctx, int msg_type,
 342                              struct nft_set *set)
 343 {
 344         struct nft_trans *trans;
 345
 346         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_set));
 347         if (trans == NULL)
 348                 return -ENOMEM;
 349
 350         if (msg_type == NFT_MSG_NEWSET && ctx->nla[NFTA_SET_ID] != NULL) {
 351                 nft_trans_set_id(trans) =
 352                         ntohl(nla_get_be32(ctx->nla[NFTA_SET_ID]));
 353                 nft_activate_next(ctx->net, set);
 354         }
 355         nft_trans_set(trans) = set;
 356         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
 357
 358         return 0;
 359 }
 360
 361 static int nft_delset(const struct nft_ctx *ctx, struct nft_set *set)
 362 {
 363         int err;
 364
 365         err = nft_trans_set_add(ctx, NFT_MSG_DELSET, set);
 366         if (err < 0)
 367                 return err;
 368
 369         nft_deactivate_next(ctx->net, set);
 370         ctx->table->use--;
 371
 372         return err;
 373 }
 374
 375 static int nft_trans_obj_add(struct nft_ctx *ctx, int msg_type,
 376                              struct nft_object *obj)
 377 {
 378         struct nft_trans *trans;
 379
 380         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_obj));
 381         if (trans == NULL)
 382                 return -ENOMEM;
 383
 384         if (msg_type == NFT_MSG_NEWOBJ)
 385                 nft_activate_next(ctx->net, obj);
 386
 387         nft_trans_obj(trans) = obj;
 388         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
 389
 390         return 0;
 391 }
 392
 393 static int nft_delobj(struct nft_ctx *ctx, struct nft_object *obj)
 394 {
 395         int err;
 396
 397         err = nft_trans_obj_add(ctx, NFT_MSG_DELOBJ, obj);
 398         if (err < 0)
 399                 return err;
 400
 401         nft_deactivate_next(ctx->net, obj);
 402         ctx->table->use--;
 403
 404         return err;
 405 }
 406
 407 /*
 408  * Tables
 409  */
 410
 411 static struct nft_table *nft_table_lookup(const struct nft_af_info *afi,
 412                                           const struct nlattr *nla,
 413                                           u8 genmask)
 414 {
 415         struct nft_table *table;
 416
 417         list_for_each_entry(table, &afi->tables, list) {
 418                 if (!nla_strcmp(nla, table->name) &&
 419                     nft_active_genmask(table, genmask))
 420                         return table;
 421         }
 422         return NULL;
 423 }
 424
 425 static struct nft_table *nf_tables_table_lookup(const struct nft_af_info *afi,
 426                                                 const struct nlattr *nla,
 427                                                 u8 genmask)
 428 {
 429         struct nft_table *table;
 430
 431         if (nla == NULL)
 432                 return ERR_PTR(-EINVAL);
 433
 434         table = nft_table_lookup(afi, nla, genmask);
 435         if (table != NULL)
 436                 return table;
 437
 438         return ERR_PTR(-ENOENT);
 439 }
 440
 441 static inline u64 nf_tables_alloc_handle(struct nft_table *table)
 442 {
 443         return ++table->hgenerator;
 444 }
 445
 446 static const struct nf_chain_type *chain_type[NFPROTO_NUMPROTO][NFT_CHAIN_T_MAX];
 447
 448 static const struct nf_chain_type *
 449 __nf_tables_chain_type_lookup(int family, const struct nlattr *nla)
 450 {
 451         int i;
 452
 453         for (i = 0; i < NFT_CHAIN_T_MAX; i++) {
 454                 if (chain_type[family][i] != NULL &&
 455                     !nla_strcmp(nla, chain_type[family][i]->name))
 456                         return chain_type[family][i];
 457         }
 458         return NULL;
 459 }
 460
 461 static const struct nf_chain_type *
 462 nf_tables_chain_type_lookup(const struct nft_af_info *afi,
 463                             const struct nlattr *nla,
 464                             bool autoload)
 465 {
 466         const struct nf_chain_type *type;
 467
 468         type = __nf_tables_chain_type_lookup(afi->family, nla);
 469         if (type != NULL)
 470                 return type;
 471 #ifdef CONFIG_MODULES
 472         if (autoload) {
 473                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
 474                 request_module("nft-chain-%u-%.*s", afi->family,
 475                                nla_len(nla), (const char *)nla_data(nla));
 476                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
 477                 type = __nf_tables_chain_type_lookup(afi->family, nla);
 478                 if (type != NULL)
 479                         return ERR_PTR(-EAGAIN);
 480         }
 481 #endif
 482         return ERR_PTR(-ENOENT);
 483 }
 484
 485 static const struct nla_policy nft_table_policy[NFTA_TABLE_MAX + 1] = {
 486         [NFTA_TABLE_NAME]       = { .type = NLA_STRING,
 487                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
 488         [NFTA_TABLE_FLAGS]      = { .type = NLA_U32 },
 489 };
 490
 491 static int nf_tables_fill_table_info(struct sk_buff *skb, struct net *net,
 492                                      u32 portid, u32 seq, int event, u32 flags,
 493                                      int family, const struct nft_table *table)
 494 {
 495         struct nlmsghdr *nlh;
 496         struct nfgenmsg *nfmsg;
 497
 498         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
 499         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags);
 500         if (nlh == NULL)
 501                 goto nla_put_failure;
 502
 503         nfmsg = nlmsg_data(nlh);
 504         nfmsg->nfgen_family     = family;
 505         nfmsg->version          = NFNETLINK_V0;
 506         nfmsg->res_id           = htons(net->nft.base_seq & 0xffff);
 507
 508         if (nla_put_string(skb, NFTA_TABLE_NAME, table->name) ||
 509             nla_put_be32(skb, NFTA_TABLE_FLAGS, htonl(table->flags)) ||
 510             nla_put_be32(skb, NFTA_TABLE_USE, htonl(table->use)))
 511                 goto nla_put_failure;
 512
 513         nlmsg_end(skb, nlh);
 514         return 0;
 515
 516 nla_put_failure:
 517         nlmsg_trim(skb, nlh);
 518         return -1;
 519 }
 520
 521 static void nf_tables_table_notify(const struct nft_ctx *ctx, int event)
 522 {
 523         struct sk_buff *skb;
 524         int err;
 525
 526         if (!ctx->report &&
 527             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
 528                 return;
 529
 530         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 531         if (skb == NULL)
 532                 goto err;
 533
 534         err = nf_tables_fill_table_info(skb, ctx->net, ctx->portid, ctx->seq,
 535                                         event, 0, ctx->afi->family, ctx->table);
 536         if (err < 0) {
 537                 kfree_skb(skb);
 538                 goto err;
 539         }
 540
 541         nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
 542                        ctx->report, GFP_KERNEL);
 543         return;
 544 err:
 545         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
 546 }
 547
 548 static int nf_tables_dump_tables(struct sk_buff *skb,
 549                                  struct netlink_callback *cb)
 550 {
 551         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
 552         const struct nft_af_info *afi;
 553         const struct nft_table *table;
 554         unsigned int idx = 0, s_idx = cb->args[0];
 555         struct net *net = sock_net(skb->sk);
 556         int family = nfmsg->nfgen_family;
 557
 558         rcu_read_lock();
 559         cb->seq = net->nft.base_seq;
 560
 561         list_for_each_entry_rcu(afi, &net->nft.af_info, list) {
 562                 if (family != NFPROTO_UNSPEC && family != afi->family)
 563                         continue;
 564
 565                 list_for_each_entry_rcu(table, &afi->tables, list) {
 566                         if (idx < s_idx)
 567                                 goto cont;
 568                         if (idx > s_idx)
 569                                 memset(&cb->args[1], 0,
 570                                        sizeof(cb->args) - sizeof(cb->args[0]));
 571                         if (!nft_is_active(net, table))
 572                                 continue;
 573                         if (nf_tables_fill_table_info(skb, net,
 574                                                       NETLINK_CB(cb->skb).portid,
 575                                                       cb->nlh->nlmsg_seq,
 576                                                       NFT_MSG_NEWTABLE,
 577                                                       NLM_F_MULTI,
 578                                                       afi->family, table) < 0)
 579                                 goto done;
 580
 581                         nl_dump_check_consistent(cb, nlmsg_hdr(skb));
 582 cont:
 583                         idx++;
 584                 }
 585         }
 586 done:
 587         rcu_read_unlock();
 588         cb->args[0] = idx;
 589         return skb->len;
 590 }
 591
 592 static int nf_tables_gettable(struct net *net, struct sock *nlsk,
 593                               struct sk_buff *skb, const struct nlmsghdr *nlh,
 594                               const struct nlattr * const nla[],
 595                               struct netlink_ext_ack *extack)
 596 {
 597         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
 598         u8 genmask = nft_genmask_cur(net);
 599         const struct nft_af_info *afi;
 600         const struct nft_table *table;
 601         struct sk_buff *skb2;
 602         int family = nfmsg->nfgen_family;
 603         int err;
 604
 605         if (nlh->nlmsg_flags & NLM_F_DUMP) {
 606                 struct netlink_dump_control c = {
 607                         .dump = nf_tables_dump_tables,
 608                 };
 609                 return netlink_dump_start(nlsk, skb, nlh, &c);
 610         }
 611
 612         afi = nf_tables_afinfo_lookup(net, family, false);
 613         if (IS_ERR(afi))
 614                 return PTR_ERR(afi);
 615
 616         table = nf_tables_table_lookup(afi, nla[NFTA_TABLE_NAME], genmask);
 617         if (IS_ERR(table))
 618                 return PTR_ERR(table);
 619
 620         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
 621         if (!skb2)
 622                 return -ENOMEM;
 623
 624         err = nf_tables_fill_table_info(skb2, net, NETLINK_CB(skb).portid,
 625                                         nlh->nlmsg_seq, NFT_MSG_NEWTABLE, 0,
 626                                         family, table);
 627         if (err < 0)
 628                 goto err;
 629
 630         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
 631
 632 err:
 633         kfree_skb(skb2);
 634         return err;
 635 }
 636
 637 static void _nf_tables_table_disable(struct net *net,
 638                                      const struct nft_af_info *afi,
 639                                      struct nft_table *table,
 640                                      u32 cnt)
 641 {
 642         struct nft_chain *chain;
 643         u32 i = 0;
 644
 645         list_for_each_entry(chain, &table->chains, list) {
 646                 if (!nft_is_active_next(net, chain))
 647                         continue;
 648                 if (!nft_is_base_chain(chain))
 649                         continue;
 650
 651                 if (cnt && i++ == cnt)
 652                         break;
 653
 654                 nf_unregister_net_hooks(net, nft_base_chain(chain)->ops,
 655                                         afi->nops);
 656         }
 657 }
 658
 659 static int nf_tables_table_enable(struct net *net,
 660                                   const struct nft_af_info *afi,
 661                                   struct nft_table *table)
 662 {
 663         struct nft_chain *chain;
 664         int err, i = 0;
 665
 666         list_for_each_entry(chain, &table->chains, list) {
 667                 if (!nft_is_active_next(net, chain))
 668                         continue;
 669                 if (!nft_is_base_chain(chain))
 670                         continue;
 671
 672                 err = nf_register_net_hooks(net, nft_base_chain(chain)->ops,
 673                                             afi->nops);
 674                 if (err < 0)
 675                         goto err;
 676
 677                 i++;
 678         }
 679         return 0;
 680 err:
 681         if (i)
 682                 _nf_tables_table_disable(net, afi, table, i);
 683         return err;
 684 }
 685
 686 static void nf_tables_table_disable(struct net *net,
 687                                     const struct nft_af_info *afi,
 688                                     struct nft_table *table)
 689 {
 690         _nf_tables_table_disable(net, afi, table, 0);
 691 }
 692
 693 static int nf_tables_updtable(struct nft_ctx *ctx)
 694 {
 695         struct nft_trans *trans;
 696         u32 flags;
 697         int ret = 0;
 698
 699         if (!ctx->nla[NFTA_TABLE_FLAGS])
 700                 return 0;
 701
 702         flags = ntohl(nla_get_be32(ctx->nla[NFTA_TABLE_FLAGS]));
 703         if (flags & ~NFT_TABLE_F_DORMANT)
 704                 return -EINVAL;
 705
 706         if (flags == ctx->table->flags)
 707                 return 0;
 708
 709         trans = nft_trans_alloc(ctx, NFT_MSG_NEWTABLE,
 710                                 sizeof(struct nft_trans_table));
 711         if (trans == NULL)
 712                 return -ENOMEM;
 713
 714         if ((flags & NFT_TABLE_F_DORMANT) &&
 715             !(ctx->table->flags & NFT_TABLE_F_DORMANT)) {
 716                 nft_trans_table_enable(trans) = false;
 717         } else if (!(flags & NFT_TABLE_F_DORMANT) &&
 718                    ctx->table->flags & NFT_TABLE_F_DORMANT) {
 719                 ret = nf_tables_table_enable(ctx->net, ctx->afi, ctx->table);
 720                 if (ret >= 0) {
 721                         ctx->table->flags &= ~NFT_TABLE_F_DORMANT;
 722                         nft_trans_table_enable(trans) = true;
 723                 }
 724         }
 725         if (ret < 0)
 726                 goto err;
 727
 728         nft_trans_table_update(trans) = true;
 729         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
 730         return 0;
 731 err:
 732         nft_trans_destroy(trans);
 733         return ret;
 734 }
 735
 736 static int nf_tables_newtable(struct net *net, struct sock *nlsk,
 737                               struct sk_buff *skb, const struct nlmsghdr *nlh,
 738                               const struct nlattr * const nla[],
 739                               struct netlink_ext_ack *extack)
 740 {
 741         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
 742         u8 genmask = nft_genmask_next(net);
 743         const struct nlattr *name;
 744         struct nft_af_info *afi;
 745         struct nft_table *table;
 746         int family = nfmsg->nfgen_family;
 747         u32 flags = 0;
 748         struct nft_ctx ctx;
 749         int err;
 750
 751         afi = nf_tables_afinfo_lookup(net, family, true);
 752         if (IS_ERR(afi))
 753                 return PTR_ERR(afi);
 754
 755         name = nla[NFTA_TABLE_NAME];
 756         table = nf_tables_table_lookup(afi, name, genmask);
 757         if (IS_ERR(table)) {
 758                 if (PTR_ERR(table) != -ENOENT)
 759                         return PTR_ERR(table);
 760         } else {
 761                 if (nlh->nlmsg_flags & NLM_F_EXCL)
 762                         return -EEXIST;
 763                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
 764                         return -EOPNOTSUPP;
 765
 766                 nft_ctx_init(&ctx, net, skb, nlh, afi, table, NULL, nla);
 767                 return nf_tables_updtable(&ctx);
 768         }
 769
 770         if (nla[NFTA_TABLE_FLAGS]) {
 771                 flags = ntohl(nla_get_be32(nla[NFTA_TABLE_FLAGS]));
 772                 if (flags & ~NFT_TABLE_F_DORMANT)
 773                         return -EINVAL;
 774         }
 775
 776         err = -EAFNOSUPPORT;
 777         if (!try_module_get(afi->owner))
 778                 goto err1;
 779
 780         err = -ENOMEM;
 781         table = kzalloc(sizeof(*table), GFP_KERNEL);
 782         if (table == NULL)
 783                 goto err2;
 784
 785         table->name = nla_strdup(name, GFP_KERNEL);
 786         if (table->name == NULL)
 787                 goto err3;
 788
 789         INIT_LIST_HEAD(&table->chains);
 790         INIT_LIST_HEAD(&table->sets);
 791         INIT_LIST_HEAD(&table->objects);
 792         table->flags = flags;
 793
 794         nft_ctx_init(&ctx, net, skb, nlh, afi, table, NULL, nla);
 795         err = nft_trans_table_add(&ctx, NFT_MSG_NEWTABLE);
 796         if (err < 0)
 797                 goto err4;
 798
 799         list_add_tail_rcu(&table->list, &afi->tables);
 800         return 0;
 801 err4:
 802         kfree(table->name);
 803 err3:
 804         kfree(table);
 805 err2:
 806         module_put(afi->owner);
 807 err1:
 808         return err;
 809 }
 810
 811 static int nft_flush_table(struct nft_ctx *ctx)
 812 {
 813         int err;
 814         struct nft_chain *chain, *nc;
 815         struct nft_object *obj, *ne;
 816         struct nft_set *set, *ns;
 817
 818         list_for_each_entry(chain, &ctx->table->chains, list) {
 819                 if (!nft_is_active_next(ctx->net, chain))
 820                         continue;
 821
 822                 ctx->chain = chain;
 823
 824                 err = nft_delrule_by_chain(ctx);
 825                 if (err < 0)
 826                         goto out;
 827         }
 828
 829         list_for_each_entry_safe(set, ns, &ctx->table->sets, list) {
 830                 if (!nft_is_active_next(ctx->net, set))
 831                         continue;
 832
 833                 if (set->flags & NFT_SET_ANONYMOUS &&
 834                     !list_empty(&set->bindings))
 835                         continue;
 836
 837                 err = nft_delset(ctx, set);
 838                 if (err < 0)
 839                         goto out;
 840         }
 841
 842         list_for_each_entry_safe(obj, ne, &ctx->table->objects, list) {
 843                 err = nft_delobj(ctx, obj);
 844                 if (err < 0)
 845                         goto out;
 846         }
 847
 848         list_for_each_entry_safe(chain, nc, &ctx->table->chains, list) {
 849                 if (!nft_is_active_next(ctx->net, chain))
 850                         continue;
 851
 852                 ctx->chain = chain;
 853
 854                 err = nft_delchain(ctx);
 855                 if (err < 0)
 856                         goto out;
 857         }
 858
 859         err = nft_deltable(ctx);
 860 out:
 861         return err;
 862 }
 863
 864 static int nft_flush(struct nft_ctx *ctx, int family)
 865 {
 866         struct nft_af_info *afi;
 867         struct nft_table *table, *nt;
 868         const struct nlattr * const *nla = ctx->nla;
 869         int err = 0;
 870
 871         list_for_each_entry(afi, &ctx->net->nft.af_info, list) {
 872                 if (family != AF_UNSPEC && afi->family != family)
 873                         continue;
 874
 875                 ctx->afi = afi;
 876                 list_for_each_entry_safe(table, nt, &afi->tables, list) {
 877                         if (!nft_is_active_next(ctx->net, table))
 878                                 continue;
 879
 880                         if (nla[NFTA_TABLE_NAME] &&
 881                             nla_strcmp(nla[NFTA_TABLE_NAME], table->name) != 0)
 882                                 continue;
 883
 884                         ctx->table = table;
 885
 886                         err = nft_flush_table(ctx);
 887                         if (err < 0)
 888                                 goto out;
 889                 }
 890         }
 891 out:
 892         return err;
 893 }
 894
 895 static int nf_tables_deltable(struct net *net, struct sock *nlsk,
 896                               struct sk_buff *skb, const struct nlmsghdr *nlh,
 897                               const struct nlattr * const nla[],
 898                               struct netlink_ext_ack *extack)
 899 {
 900         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
 901         u8 genmask = nft_genmask_next(net);
 902         struct nft_af_info *afi;
 903         struct nft_table *table;
 904         int family = nfmsg->nfgen_family;
 905         struct nft_ctx ctx;
 906
 907         nft_ctx_init(&ctx, net, skb, nlh, NULL, NULL, NULL, nla);
 908         if (family == AF_UNSPEC || nla[NFTA_TABLE_NAME] == NULL)
 909                 return nft_flush(&ctx, family);
 910
 911         afi = nf_tables_afinfo_lookup(net, family, false);
 912         if (IS_ERR(afi))
 913                 return PTR_ERR(afi);
 914
 915         table = nf_tables_table_lookup(afi, nla[NFTA_TABLE_NAME], genmask);
 916         if (IS_ERR(table))
 917                 return PTR_ERR(table);
 918
 919         if (nlh->nlmsg_flags & NLM_F_NONREC &&
 920             table->use > 0)
 921                 return -EBUSY;
 922
 923         ctx.afi = afi;
 924         ctx.table = table;
 925
 926         return nft_flush_table(&ctx);
 927 }
 928
 929 static void nf_tables_table_destroy(struct nft_ctx *ctx)
 930 {
 931         BUG_ON(ctx->table->use > 0);
 932
 933         kfree(ctx->table->name);
 934         kfree(ctx->table);
 935         module_put(ctx->afi->owner);
 936 }
 937
 938 int nft_register_chain_type(const struct nf_chain_type *ctype)
 939 {
 940         int err = 0;
 941
 942         if (WARN_ON(ctype->family >= NFPROTO_NUMPROTO))
 943                 return -EINVAL;
 944
 945         nfnl_lock(NFNL_SUBSYS_NFTABLES);
 946         if (chain_type[ctype->family][ctype->type] != NULL) {
 947                 err = -EBUSY;
 948                 goto out;
 949         }
 950         chain_type[ctype->family][ctype->type] = ctype;
 951 out:
 952         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
 953         return err;
 954 }
 955 EXPORT_SYMBOL_GPL(nft_register_chain_type);
 956
 957 void nft_unregister_chain_type(const struct nf_chain_type *ctype)
 958 {
 959         nfnl_lock(NFNL_SUBSYS_NFTABLES);
 960         chain_type[ctype->family][ctype->type] = NULL;
 961         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
 962 }
 963 EXPORT_SYMBOL_GPL(nft_unregister_chain_type);
 964
 965 /*
 966  * Chains
 967  */
 968
 969 static struct nft_chain *
 970 nf_tables_chain_lookup_byhandle(const struct nft_table *table, u64 handle,
 971                                 u8 genmask)
 972 {
 973         struct nft_chain *chain;
 974
 975         list_for_each_entry(chain, &table->chains, list) {
 976                 if (chain->handle == handle &&
 977                     nft_active_genmask(chain, genmask))
 978                         return chain;
 979         }
 980
 981         return ERR_PTR(-ENOENT);
 982 }
 983
 984 static struct nft_chain *nf_tables_chain_lookup(const struct nft_table *table,
 985                                                 const struct nlattr *nla,
 986                                                 u8 genmask)
 987 {
 988         struct nft_chain *chain;
 989
 990         if (nla == NULL)
 991                 return ERR_PTR(-EINVAL);
 992
 993         list_for_each_entry(chain, &table->chains, list) {
 994                 if (!nla_strcmp(nla, chain->name) &&
 995                     nft_active_genmask(chain, genmask))
 996                         return chain;
 997         }
 998
 999         return ERR_PTR(-ENOENT);
1000 }
1001
1002 static const struct nla_policy nft_chain_policy[NFTA_CHAIN_MAX + 1] = {
1003         [NFTA_CHAIN_TABLE]      = { .type = NLA_STRING,
1004                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
1005         [NFTA_CHAIN_HANDLE]     = { .type = NLA_U64 },
1006         [NFTA_CHAIN_NAME]       = { .type = NLA_STRING,
1007                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
1008         [NFTA_CHAIN_HOOK]       = { .type = NLA_NESTED },
1009         [NFTA_CHAIN_POLICY]     = { .type = NLA_U32 },
1010         [NFTA_CHAIN_TYPE]       = { .type = NLA_STRING },
1011         [NFTA_CHAIN_COUNTERS]   = { .type = NLA_NESTED },
1012 };
1013
1014 static const struct nla_policy nft_hook_policy[NFTA_HOOK_MAX + 1] = {
1015         [NFTA_HOOK_HOOKNUM]     = { .type = NLA_U32 },
1016         [NFTA_HOOK_PRIORITY]    = { .type = NLA_U32 },
1017         [NFTA_HOOK_DEV]         = { .type = NLA_STRING,
1018                                     .len = IFNAMSIZ - 1 },
1019 };
1020
1021 static int nft_dump_stats(struct sk_buff *skb, struct nft_stats __percpu *stats)
1022 {
1023         struct nft_stats *cpu_stats, total;
1024         struct nlattr *nest;
1025         unsigned int seq;
1026         u64 pkts, bytes;
1027         int cpu;
1028
1029         memset(&total, 0, sizeof(total));
1030         for_each_possible_cpu(cpu) {
1031                 cpu_stats = per_cpu_ptr(stats, cpu);
1032                 do {
1033                         seq = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
1034                         pkts = cpu_stats->pkts;
1035                         bytes = cpu_stats->bytes;
1036                 } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, seq));
1037                 total.pkts += pkts;
1038                 total.bytes += bytes;
1039         }
1040         nest = nla_nest_start(skb, NFTA_CHAIN_COUNTERS);
1041         if (nest == NULL)
1042                 goto nla_put_failure;
1043
1044         if (nla_put_be64(skb, NFTA_COUNTER_PACKETS, cpu_to_be64(total.pkts),
1045                          NFTA_COUNTER_PAD) ||
1046             nla_put_be64(skb, NFTA_COUNTER_BYTES, cpu_to_be64(total.bytes),
1047                          NFTA_COUNTER_PAD))
1048                 goto nla_put_failure;
1049
1050         nla_nest_end(skb, nest);
1051         return 0;
1052
1053 nla_put_failure:
1054         return -ENOSPC;
1055 }
1056
1057 static int nf_tables_fill_chain_info(struct sk_buff *skb, struct net *net,
1058                                      u32 portid, u32 seq, int event, u32 flags,
1059                                      int family, const struct nft_table *table,
1060                                      const struct nft_chain *chain)
1061 {
1062         struct nlmsghdr *nlh;
1063         struct nfgenmsg *nfmsg;
1064
1065         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
1066         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags);
1067         if (nlh == NULL)
1068                 goto nla_put_failure;
1069
1070         nfmsg = nlmsg_data(nlh);
1071         nfmsg->nfgen_family     = family;
1072         nfmsg->version          = NFNETLINK_V0;
1073         nfmsg->res_id           = htons(net->nft.base_seq & 0xffff);
1074
1075         if (nla_put_string(skb, NFTA_CHAIN_TABLE, table->name))
1076                 goto nla_put_failure;
1077         if (nla_put_be64(skb, NFTA_CHAIN_HANDLE, cpu_to_be64(chain->handle),
1078                          NFTA_CHAIN_PAD))
1079                 goto nla_put_failure;
1080         if (nla_put_string(skb, NFTA_CHAIN_NAME, chain->name))
1081                 goto nla_put_failure;
1082
1083         if (nft_is_base_chain(chain)) {
1084                 const struct nft_base_chain *basechain = nft_base_chain(chain);
1085                 const struct nf_hook_ops *ops = &basechain->ops[0];
1086                 struct nlattr *nest;
1087
1088                 nest = nla_nest_start(skb, NFTA_CHAIN_HOOK);
1089                 if (nest == NULL)
1090                         goto nla_put_failure;
1091                 if (nla_put_be32(skb, NFTA_HOOK_HOOKNUM, htonl(ops->hooknum)))
1092                         goto nla_put_failure;
1093                 if (nla_put_be32(skb, NFTA_HOOK_PRIORITY, htonl(ops->priority)))
1094                         goto nla_put_failure;
1095                 if (basechain->dev_name[0] &&
1096                     nla_put_string(skb, NFTA_HOOK_DEV, basechain->dev_name))
1097                         goto nla_put_failure;
1098                 nla_nest_end(skb, nest);
1099
1100                 if (nla_put_be32(skb, NFTA_CHAIN_POLICY,
1101                                  htonl(basechain->policy)))
1102                         goto nla_put_failure;
1103
1104                 if (nla_put_string(skb, NFTA_CHAIN_TYPE, basechain->type->name))
1105                         goto nla_put_failure;
1106
1107                 if (basechain->stats && nft_dump_stats(skb, basechain->stats))
1108                         goto nla_put_failure;
1109         }
1110
1111         if (nla_put_be32(skb, NFTA_CHAIN_USE, htonl(chain->use)))
1112                 goto nla_put_failure;
1113
1114         nlmsg_end(skb, nlh);
1115         return 0;
1116
1117 nla_put_failure:
1118         nlmsg_trim(skb, nlh);
1119         return -1;
1120 }
1121
1122 static void nf_tables_chain_notify(const struct nft_ctx *ctx, int event)
1123 {
1124         struct sk_buff *skb;
1125         int err;
1126
1127         if (!ctx->report &&
1128             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
1129                 return;
1130
1131         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1132         if (skb == NULL)
1133                 goto err;
1134
1135         err = nf_tables_fill_chain_info(skb, ctx->net, ctx->portid, ctx->seq,
1136                                         event, 0, ctx->afi->family, ctx->table,
1137                                         ctx->chain);
1138         if (err < 0) {
1139                 kfree_skb(skb);
1140                 goto err;
1141         }
1142
1143         nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
1144                        ctx->report, GFP_KERNEL);
1145         return;
1146 err:
1147         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
1148 }
1149
1150 static int nf_tables_dump_chains(struct sk_buff *skb,
1151                                  struct netlink_callback *cb)
1152 {
1153         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
1154         const struct nft_af_info *afi;
1155         const struct nft_table *table;
1156         const struct nft_chain *chain;
1157         unsigned int idx = 0, s_idx = cb->args[0];
1158         struct net *net = sock_net(skb->sk);
1159         int family = nfmsg->nfgen_family;
1160
1161         rcu_read_lock();
1162         cb->seq = net->nft.base_seq;
1163
1164         list_for_each_entry_rcu(afi, &net->nft.af_info, list) {
1165                 if (family != NFPROTO_UNSPEC && family != afi->family)
1166                         continue;
1167
1168                 list_for_each_entry_rcu(table, &afi->tables, list) {
1169                         list_for_each_entry_rcu(chain, &table->chains, list) {
1170                                 if (idx < s_idx)
1171                                         goto cont;
1172                                 if (idx > s_idx)
1173                                         memset(&cb->args[1], 0,
1174                                                sizeof(cb->args) - sizeof(cb->args[0]));
1175                                 if (!nft_is_active(net, chain))
1176                                         continue;
1177                                 if (nf_tables_fill_chain_info(skb, net,
1178                                                               NETLINK_CB(cb->skb).portid,
1179                                                               cb->nlh->nlmsg_seq,
1180                                                               NFT_MSG_NEWCHAIN,
1181                                                               NLM_F_MULTI,
1182                                                               afi->family, table, chain) < 0)
1183                                         goto done;
1184
1185                                 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
1186 cont:
1187                                 idx++;
1188                         }
1189                 }
1190         }
1191 done:
1192         rcu_read_unlock();
1193         cb->args[0] = idx;
1194         return skb->len;
1195 }
1196
1197 static int nf_tables_getchain(struct net *net, struct sock *nlsk,
1198                               struct sk_buff *skb, const struct nlmsghdr *nlh,
1199                               const struct nlattr * const nla[],
1200                               struct netlink_ext_ack *extack)
1201 {
1202         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1203         u8 genmask = nft_genmask_cur(net);
1204         const struct nft_af_info *afi;
1205         const struct nft_table *table;
1206         const struct nft_chain *chain;
1207         struct sk_buff *skb2;
1208         int family = nfmsg->nfgen_family;
1209         int err;
1210
1211         if (nlh->nlmsg_flags & NLM_F_DUMP) {
1212                 struct netlink_dump_control c = {
1213                         .dump = nf_tables_dump_chains,
1214                 };
1215                 return netlink_dump_start(nlsk, skb, nlh, &c);
1216         }
1217
1218         afi = nf_tables_afinfo_lookup(net, family, false);
1219         if (IS_ERR(afi))
1220                 return PTR_ERR(afi);
1221
1222         table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE], genmask);
1223         if (IS_ERR(table))
1224                 return PTR_ERR(table);
1225
1226         chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME], genmask);
1227         if (IS_ERR(chain))
1228                 return PTR_ERR(chain);
1229
1230         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1231         if (!skb2)
1232                 return -ENOMEM;
1233
1234         err = nf_tables_fill_chain_info(skb2, net, NETLINK_CB(skb).portid,
1235                                         nlh->nlmsg_seq, NFT_MSG_NEWCHAIN, 0,
1236                                         family, table, chain);
1237         if (err < 0)
1238                 goto err;
1239
1240         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
1241
1242 err:
1243         kfree_skb(skb2);
1244         return err;
1245 }
1246
1247 static const struct nla_policy nft_counter_policy[NFTA_COUNTER_MAX + 1] = {
1248         [NFTA_COUNTER_PACKETS]  = { .type = NLA_U64 },
1249         [NFTA_COUNTER_BYTES]    = { .type = NLA_U64 },
1250 };
1251
1252 static struct nft_stats __percpu *nft_stats_alloc(const struct nlattr *attr)
1253 {
1254         struct nlattr *tb[NFTA_COUNTER_MAX+1];
1255         struct nft_stats __percpu *newstats;
1256         struct nft_stats *stats;
1257         int err;
1258
1259         err = nla_parse_nested(tb, NFTA_COUNTER_MAX, attr, nft_counter_policy,
1260                                NULL);
1261         if (err < 0)
1262                 return ERR_PTR(err);
1263
1264         if (!tb[NFTA_COUNTER_BYTES] || !tb[NFTA_COUNTER_PACKETS])
1265                 return ERR_PTR(-EINVAL);
1266
1267         newstats = netdev_alloc_pcpu_stats(struct nft_stats);
1268         if (newstats == NULL)
1269                 return ERR_PTR(-ENOMEM);
1270
1271         /* Restore old counters on this cpu, no problem. Per-cpu statistics
1272          * are not exposed to userspace.
1273          */
1274         preempt_disable();
1275         stats = this_cpu_ptr(newstats);
1276         stats->bytes = be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_BYTES]));
1277         stats->pkts = be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_PACKETS]));
1278         preempt_enable();
1279
1280         return newstats;
1281 }
1282
1283 static void nft_chain_stats_replace(struct nft_base_chain *chain,
1284                                     struct nft_stats __percpu *newstats)
1285 {
1286         if (newstats == NULL)
1287                 return;
1288
1289         if (chain->stats) {
1290                 struct nft_stats __percpu *oldstats =
1291                                 nft_dereference(chain->stats);
1292
1293                 rcu_assign_pointer(chain->stats, newstats);
1294                 synchronize_rcu();
1295                 free_percpu(oldstats);
1296         } else {
1297                 rcu_assign_pointer(chain->stats, newstats);
1298                 static_branch_inc(&nft_counters_enabled);
1299         }
1300 }
1301
1302 static void nf_tables_chain_destroy(struct nft_chain *chain)
1303 {
1304         BUG_ON(chain->use > 0);
1305
1306         if (nft_is_base_chain(chain)) {
1307                 struct nft_base_chain *basechain = nft_base_chain(chain);
1308
1309                 module_put(basechain->type->owner);
1310                 free_percpu(basechain->stats);
1311                 if (basechain->stats)
1312                         static_branch_dec(&nft_counters_enabled);
1313                 if (basechain->ops[0].dev != NULL)
1314                         dev_put(basechain->ops[0].dev);
1315                 kfree(chain->name);
1316                 kfree(basechain);
1317         } else {
1318                 kfree(chain->name);
1319                 kfree(chain);
1320         }
1321 }
1322
1323 struct nft_chain_hook {
1324         u32                             num;
1325         u32                             priority;
1326         const struct nf_chain_type      *type;
1327         struct net_device               *dev;
1328 };
1329
1330 static int nft_chain_parse_hook(struct net *net,
1331                                 const struct nlattr * const nla[],
1332                                 struct nft_af_info *afi,
1333                                 struct nft_chain_hook *hook, bool create)
1334 {
1335         struct nlattr *ha[NFTA_HOOK_MAX + 1];
1336         const struct nf_chain_type *type;
1337         struct net_device *dev;
1338         int err;
1339
1340         err = nla_parse_nested(ha, NFTA_HOOK_MAX, nla[NFTA_CHAIN_HOOK],
1341                                nft_hook_policy, NULL);
1342         if (err < 0)
1343                 return err;
1344
1345         if (ha[NFTA_HOOK_HOOKNUM] == NULL ||
1346             ha[NFTA_HOOK_PRIORITY] == NULL)
1347                 return -EINVAL;
1348
1349         hook->num = ntohl(nla_get_be32(ha[NFTA_HOOK_HOOKNUM]));
1350         if (hook->num >= afi->nhooks)
1351                 return -EINVAL;
1352
1353         hook->priority = ntohl(nla_get_be32(ha[NFTA_HOOK_PRIORITY]));
1354
1355         type = chain_type[afi->family][NFT_CHAIN_T_DEFAULT];
1356         if (nla[NFTA_CHAIN_TYPE]) {
1357                 type = nf_tables_chain_type_lookup(afi, nla[NFTA_CHAIN_TYPE],
1358                                                    create);
1359                 if (IS_ERR(type))
1360                         return PTR_ERR(type);
1361         }
1362         if (!(type->hook_mask & (1 << hook->num)))
1363                 return -EOPNOTSUPP;
1364         if (!try_module_get(type->owner))
1365                 return -ENOENT;
1366
1367         hook->type = type;
1368
1369         hook->dev = NULL;
1370         if (afi->flags & NFT_AF_NEEDS_DEV) {
1371                 char ifname[IFNAMSIZ];
1372
1373                 if (!ha[NFTA_HOOK_DEV]) {
1374                         module_put(type->owner);
1375                         return -EOPNOTSUPP;
1376                 }
1377
1378                 nla_strlcpy(ifname, ha[NFTA_HOOK_DEV], IFNAMSIZ);
1379                 dev = dev_get_by_name(net, ifname);
1380                 if (!dev) {
1381                         module_put(type->owner);
1382                         return -ENOENT;
1383                 }
1384                 hook->dev = dev;
1385         } else if (ha[NFTA_HOOK_DEV]) {
1386                 module_put(type->owner);
1387                 return -EOPNOTSUPP;
1388         }
1389
1390         return 0;
1391 }
1392
1393 static void nft_chain_release_hook(struct nft_chain_hook *hook)
1394 {
1395         module_put(hook->type->owner);
1396         if (hook->dev != NULL)
1397                 dev_put(hook->dev);
1398 }
1399
1400 static int nf_tables_addchain(struct nft_ctx *ctx, u8 family, u8 genmask,
1401                               u8 policy, bool create)
1402 {
1403         const struct nlattr * const *nla = ctx->nla;
1404         struct nft_table *table = ctx->table;
1405         struct nft_af_info *afi = ctx->afi;
1406         struct nft_base_chain *basechain;
1407         struct nft_stats __percpu *stats;
1408         struct net *net = ctx->net;
1409         struct nft_chain *chain;
1410         unsigned int i;
1411         int err;
1412
1413         if (table->use == UINT_MAX)
1414                 return -EOVERFLOW;
1415
1416         if (nla[NFTA_CHAIN_HOOK]) {
1417                 struct nft_chain_hook hook;
1418                 struct nf_hook_ops *ops;
1419                 nf_hookfn *hookfn;
1420
1421                 err = nft_chain_parse_hook(net, nla, afi, &hook, create);
1422                 if (err < 0)
1423                         return err;
1424
1425                 basechain = kzalloc(sizeof(*basechain), GFP_KERNEL);
1426                 if (basechain == NULL) {
1427                         nft_chain_release_hook(&hook);
1428                         return -ENOMEM;
1429                 }
1430
1431                 if (hook.dev != NULL)
1432                         strncpy(basechain->dev_name, hook.dev->name, IFNAMSIZ);
1433
1434                 if (nla[NFTA_CHAIN_COUNTERS]) {
1435                         stats = nft_stats_alloc(nla[NFTA_CHAIN_COUNTERS]);
1436                         if (IS_ERR(stats)) {
1437                                 nft_chain_release_hook(&hook);
1438                                 kfree(basechain);
1439                                 return PTR_ERR(stats);
1440                         }
1441                         basechain->stats = stats;
1442                         static_branch_inc(&nft_counters_enabled);
1443                 }
1444
1445                 hookfn = hook.type->hooks[hook.num];
1446                 basechain->type = hook.type;
1447                 chain = &basechain->chain;
1448
1449                 for (i = 0; i < afi->nops; i++) {
1450                         ops = &basechain->ops[i];
1451                         ops->pf         = family;
1452                         ops->hooknum    = hook.num;
1453                         ops->priority   = hook.priority;
1454                         ops->priv       = chain;
1455                         ops->hook       = afi->hooks[ops->hooknum];
1456                         ops->dev        = hook.dev;
1457                         if (hookfn)
1458                                 ops->hook = hookfn;
1459                         if (afi->hook_ops_init)
1460                                 afi->hook_ops_init(ops, i);
1461                 }
1462
1463                 chain->flags |= NFT_BASE_CHAIN;
1464                 basechain->policy = policy;
1465         } else {
1466                 chain = kzalloc(sizeof(*chain), GFP_KERNEL);
1467                 if (chain == NULL)
1468                         return -ENOMEM;
1469         }
1470         INIT_LIST_HEAD(&chain->rules);
1471         chain->handle = nf_tables_alloc_handle(table);
1472         chain->table = table;
1473         chain->name = nla_strdup(nla[NFTA_CHAIN_NAME], GFP_KERNEL);
1474         if (!chain->name) {
1475                 err = -ENOMEM;
1476                 goto err1;
1477         }
1478
1479         err = nf_tables_register_hooks(net, table, chain, afi->nops);
1480         if (err < 0)
1481                 goto err1;
1482
1483         ctx->chain = chain;
1484         err = nft_trans_chain_add(ctx, NFT_MSG_NEWCHAIN);
1485         if (err < 0)
1486                 goto err2;
1487
1488         table->use++;
1489         list_add_tail_rcu(&chain->list, &table->chains);
1490
1491         return 0;
1492 err2:
1493         nf_tables_unregister_hooks(net, table, chain, afi->nops);
1494 err1:
1495         nf_tables_chain_destroy(chain);
1496
1497         return err;
1498 }
1499
1500 static int nf_tables_updchain(struct nft_ctx *ctx, u8 genmask, u8 policy,
1501                               bool create)
1502 {
1503         const struct nlattr * const *nla = ctx->nla;
1504         struct nft_table *table = ctx->table;
1505         struct nft_chain *chain = ctx->chain;
1506         struct nft_af_info *afi = ctx->afi;
1507         struct nft_base_chain *basechain;
1508         struct nft_stats *stats = NULL;
1509         struct nft_chain_hook hook;
1510         struct nf_hook_ops *ops;
1511         struct nft_trans *trans;
1512         int err, i;
1513
1514         if (nla[NFTA_CHAIN_HOOK]) {
1515                 if (!nft_is_base_chain(chain))
1516                         return -EBUSY;
1517
1518                 err = nft_chain_parse_hook(ctx->net, nla, ctx->afi, &hook,
1519                                            create);
1520                 if (err < 0)
1521                         return err;
1522
1523                 basechain = nft_base_chain(chain);
1524                 if (basechain->type != hook.type) {
1525                         nft_chain_release_hook(&hook);
1526                         return -EBUSY;
1527                 }
1528
1529                 for (i = 0; i < afi->nops; i++) {
1530                         ops = &basechain->ops[i];
1531                         if (ops->hooknum != hook.num ||
1532                             ops->priority != hook.priority ||
1533                             ops->dev != hook.dev) {
1534                                 nft_chain_release_hook(&hook);
1535                                 return -EBUSY;
1536                         }
1537                 }
1538                 nft_chain_release_hook(&hook);
1539         }
1540
1541         if (nla[NFTA_CHAIN_HANDLE] &&
1542             nla[NFTA_CHAIN_NAME]) {
1543                 struct nft_chain *chain2;
1544
1545                 chain2 = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME],
1546                                                 genmask);
1547                 if (!IS_ERR(chain2))
1548                         return -EEXIST;
1549         }
1550
1551         if (nla[NFTA_CHAIN_COUNTERS]) {
1552                 if (!nft_is_base_chain(chain))
1553                         return -EOPNOTSUPP;
1554
1555                 stats = nft_stats_alloc(nla[NFTA_CHAIN_COUNTERS]);
1556                 if (IS_ERR(stats))
1557                         return PTR_ERR(stats);
1558         }
1559
1560         err = -ENOMEM;
1561         trans = nft_trans_alloc(ctx, NFT_MSG_NEWCHAIN,
1562                                 sizeof(struct nft_trans_chain));
1563         if (trans == NULL)
1564                 goto err;
1565
1566         nft_trans_chain_stats(trans) = stats;
1567         nft_trans_chain_update(trans) = true;
1568
1569         if (nla[NFTA_CHAIN_POLICY])
1570                 nft_trans_chain_policy(trans) = policy;
1571         else
1572                 nft_trans_chain_policy(trans) = -1;
1573
1574         if (nla[NFTA_CHAIN_HANDLE] &&
1575             nla[NFTA_CHAIN_NAME]) {
1576                 struct nft_trans *tmp;
1577                 char *name;
1578
1579                 err = -ENOMEM;
1580                 name = nla_strdup(nla[NFTA_CHAIN_NAME], GFP_KERNEL);
1581                 if (!name)
1582                         goto err;
1583
1584                 err = -EEXIST;
1585                 list_for_each_entry(tmp, &ctx->net->nft.commit_list, list) {
1586                         if (tmp->msg_type == NFT_MSG_NEWCHAIN &&
1587                             tmp->ctx.table == table &&
1588                             nft_trans_chain_update(tmp) &&
1589                             nft_trans_chain_name(tmp) &&
1590                             strcmp(name, nft_trans_chain_name(tmp)) == 0) {
1591                                 kfree(name);
1592                                 goto err;
1593                         }
1594                 }
1595
1596                 nft_trans_chain_name(trans) = name;
1597         }
1598         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
1599
1600         return 0;
1601 err:
1602         free_percpu(stats);
1603         kfree(trans);
1604         return err;
1605 }
1606
1607 static int nf_tables_newchain(struct net *net, struct sock *nlsk,
1608                               struct sk_buff *skb, const struct nlmsghdr *nlh,
1609                               const struct nlattr * const nla[],
1610                               struct netlink_ext_ack *extack)
1611 {
1612         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1613         const struct nlattr * uninitialized_var(name);
1614         u8 genmask = nft_genmask_next(net);
1615         int family = nfmsg->nfgen_family;
1616         struct nft_af_info *afi;
1617         struct nft_table *table;
1618         struct nft_chain *chain;
1619         u8 policy = NF_ACCEPT;
1620         struct nft_ctx ctx;
1621         u64 handle = 0;
1622         bool create;
1623
1624         create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false;
1625
1626         afi = nf_tables_afinfo_lookup(net, family, true);
1627         if (IS_ERR(afi))
1628                 return PTR_ERR(afi);
1629
1630         table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE], genmask);
1631         if (IS_ERR(table))
1632                 return PTR_ERR(table);
1633
1634         chain = NULL;
1635         name = nla[NFTA_CHAIN_NAME];
1636
1637         if (nla[NFTA_CHAIN_HANDLE]) {
1638                 handle = be64_to_cpu(nla_get_be64(nla[NFTA_CHAIN_HANDLE]));
1639                 chain = nf_tables_chain_lookup_byhandle(table, handle, genmask);
1640                 if (IS_ERR(chain))
1641                         return PTR_ERR(chain);
1642         } else {
1643                 chain = nf_tables_chain_lookup(table, name, genmask);
1644                 if (IS_ERR(chain)) {
1645                         if (PTR_ERR(chain) != -ENOENT)
1646                                 return PTR_ERR(chain);
1647                         chain = NULL;
1648                 }
1649         }
1650
1651         if (nla[NFTA_CHAIN_POLICY]) {
1652                 if (chain != NULL &&
1653                     !nft_is_base_chain(chain))
1654                         return -EOPNOTSUPP;
1655
1656                 if (chain == NULL &&
1657                     nla[NFTA_CHAIN_HOOK] == NULL)
1658                         return -EOPNOTSUPP;
1659
1660                 policy = ntohl(nla_get_be32(nla[NFTA_CHAIN_POLICY]));
1661                 switch (policy) {
1662                 case NF_DROP:
1663                 case NF_ACCEPT:
1664                         break;
1665                 default:
1666                         return -EINVAL;
1667                 }
1668         }
1669
1670         nft_ctx_init(&ctx, net, skb, nlh, afi, table, chain, nla);
1671
1672         if (chain != NULL) {
1673                 if (nlh->nlmsg_flags & NLM_F_EXCL)
1674                         return -EEXIST;
1675                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
1676                         return -EOPNOTSUPP;
1677
1678                 return nf_tables_updchain(&ctx, genmask, policy, create);
1679         }
1680
1681         return nf_tables_addchain(&ctx, family, genmask, policy, create);
1682 }
1683
1684 static int nf_tables_delchain(struct net *net, struct sock *nlsk,
1685                               struct sk_buff *skb, const struct nlmsghdr *nlh,
1686                               const struct nlattr * const nla[],
1687                               struct netlink_ext_ack *extack)
1688 {
1689         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1690         u8 genmask = nft_genmask_next(net);
1691         struct nft_af_info *afi;
1692         struct nft_table *table;
1693         struct nft_chain *chain;
1694         struct nft_rule *rule;
1695         int family = nfmsg->nfgen_family;
1696         struct nft_ctx ctx;
1697         u32 use;
1698         int err;
1699
1700         afi = nf_tables_afinfo_lookup(net, family, false);
1701         if (IS_ERR(afi))
1702                 return PTR_ERR(afi);
1703
1704         table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE], genmask);
1705         if (IS_ERR(table))
1706                 return PTR_ERR(table);
1707
1708         chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME], genmask);
1709         if (IS_ERR(chain))
1710                 return PTR_ERR(chain);
1711
1712         if (nlh->nlmsg_flags & NLM_F_NONREC &&
1713             chain->use > 0)
1714                 return -EBUSY;
1715
1716         nft_ctx_init(&ctx, net, skb, nlh, afi, table, chain, nla);
1717
1718         use = chain->use;
1719         list_for_each_entry(rule, &chain->rules, list) {
1720                 if (!nft_is_active_next(net, rule))
1721                         continue;
1722                 use--;
1723
1724                 err = nft_delrule(&ctx, rule);
1725                 if (err < 0)
1726                         return err;
1727         }
1728
1729         /* There are rules and elements that are still holding references to us,
1730          * we cannot do a recursive removal in this case.
1731          */
1732         if (use > 0)
1733                 return -EBUSY;
1734
1735         return nft_delchain(&ctx);
1736 }
1737
1738 /*
1739  * Expressions
1740  */
1741
1742 /**
1743  *      nft_register_expr - register nf_tables expr type
1744  *      @ops: expr type
1745  *
1746  *      Registers the expr type for use with nf_tables. Returns zero on
1747  *      success or a negative errno code otherwise.
1748  */
1749 int nft_register_expr(struct nft_expr_type *type)
1750 {
1751         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1752         if (type->family == NFPROTO_UNSPEC)
1753                 list_add_tail_rcu(&type->list, &nf_tables_expressions);
1754         else
1755                 list_add_rcu(&type->list, &nf_tables_expressions);
1756         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1757         return 0;
1758 }
1759 EXPORT_SYMBOL_GPL(nft_register_expr);
1760
1761 /**
1762  *      nft_unregister_expr - unregister nf_tables expr type
1763  *      @ops: expr type
1764  *
1765  *      Unregisters the expr typefor use with nf_tables.
1766  */
1767 void nft_unregister_expr(struct nft_expr_type *type)
1768 {
1769         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1770         list_del_rcu(&type->list);
1771         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1772 }
1773 EXPORT_SYMBOL_GPL(nft_unregister_expr);
1774
1775 static const struct nft_expr_type *__nft_expr_type_get(u8 family,
1776                                                        struct nlattr *nla)
1777 {
1778         const struct nft_expr_type *type;
1779
1780         list_for_each_entry(type, &nf_tables_expressions, list) {
1781                 if (!nla_strcmp(nla, type->name) &&
1782                     (!type->family || type->family == family))
1783                         return type;
1784         }
1785         return NULL;
1786 }
1787
1788 static const struct nft_expr_type *nft_expr_type_get(u8 family,
1789                                                      struct nlattr *nla)
1790 {
1791         const struct nft_expr_type *type;
1792
1793         if (nla == NULL)
1794                 return ERR_PTR(-EINVAL);
1795
1796         type = __nft_expr_type_get(family, nla);
1797         if (type != NULL && try_module_get(type->owner))
1798                 return type;
1799
1800 #ifdef CONFIG_MODULES
1801         if (type == NULL) {
1802                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1803                 request_module("nft-expr-%u-%.*s", family,
1804                                nla_len(nla), (char *)nla_data(nla));
1805                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
1806                 if (__nft_expr_type_get(family, nla))
1807                         return ERR_PTR(-EAGAIN);
1808
1809                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1810                 request_module("nft-expr-%.*s",
1811                                nla_len(nla), (char *)nla_data(nla));
1812                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
1813                 if (__nft_expr_type_get(family, nla))
1814                         return ERR_PTR(-EAGAIN);
1815         }
1816 #endif
1817         return ERR_PTR(-ENOENT);
1818 }
1819
1820 static const struct nla_policy nft_expr_policy[NFTA_EXPR_MAX + 1] = {
1821         [NFTA_EXPR_NAME]        = { .type = NLA_STRING },
1822         [NFTA_EXPR_DATA]        = { .type = NLA_NESTED },
1823 };
1824
1825 static int nf_tables_fill_expr_info(struct sk_buff *skb,
1826                                     const struct nft_expr *expr)
1827 {
1828         if (nla_put_string(skb, NFTA_EXPR_NAME, expr->ops->type->name))
1829                 goto nla_put_failure;
1830
1831         if (expr->ops->dump) {
1832                 struct nlattr *data = nla_nest_start(skb, NFTA_EXPR_DATA);
1833                 if (data == NULL)
1834                         goto nla_put_failure;
1835                 if (expr->ops->dump(skb, expr) < 0)
1836                         goto nla_put_failure;
1837                 nla_nest_end(skb, data);
1838         }
1839
1840         return skb->len;
1841
1842 nla_put_failure:
1843         return -1;
1844 };
1845
1846 int nft_expr_dump(struct sk_buff *skb, unsigned int attr,
1847                   const struct nft_expr *expr)
1848 {
1849         struct nlattr *nest;
1850
1851         nest = nla_nest_start(skb, attr);
1852         if (!nest)
1853                 goto nla_put_failure;
1854         if (nf_tables_fill_expr_info(skb, expr) < 0)
1855                 goto nla_put_failure;
1856         nla_nest_end(skb, nest);
1857         return 0;
1858
1859 nla_put_failure:
1860         return -1;
1861 }
1862
1863 struct nft_expr_info {
1864         const struct nft_expr_ops       *ops;
1865         struct nlattr                   *tb[NFT_EXPR_MAXATTR + 1];
1866 };
1867
1868 static int nf_tables_expr_parse(const struct nft_ctx *ctx,
1869                                 const struct nlattr *nla,
1870                                 struct nft_expr_info *info)
1871 {
1872         const struct nft_expr_type *type;
1873         const struct nft_expr_ops *ops;
1874         struct nlattr *tb[NFTA_EXPR_MAX + 1];
1875         int err;
1876
1877         err = nla_parse_nested(tb, NFTA_EXPR_MAX, nla, nft_expr_policy, NULL);
1878         if (err < 0)
1879                 return err;
1880
1881         type = nft_expr_type_get(ctx->afi->family, tb[NFTA_EXPR_NAME]);
1882         if (IS_ERR(type))
1883                 return PTR_ERR(type);
1884
1885         if (tb[NFTA_EXPR_DATA]) {
1886                 err = nla_parse_nested(info->tb, type->maxattr,
1887                                        tb[NFTA_EXPR_DATA], type->policy, NULL);
1888                 if (err < 0)
1889                         goto err1;
1890         } else
1891                 memset(info->tb, 0, sizeof(info->tb[0]) * (type->maxattr + 1));
1892
1893         if (type->select_ops != NULL) {
1894                 ops = type->select_ops(ctx,
1895                                        (const struct nlattr * const *)info->tb);
1896                 if (IS_ERR(ops)) {
1897                         err = PTR_ERR(ops);
1898                         goto err1;
1899                 }
1900         } else
1901                 ops = type->ops;
1902
1903         info->ops = ops;
1904         return 0;
1905
1906 err1:
1907         module_put(type->owner);
1908         return err;
1909 }
1910
1911 static int nf_tables_newexpr(const struct nft_ctx *ctx,
1912                              const struct nft_expr_info *info,
1913                              struct nft_expr *expr)
1914 {
1915         const struct nft_expr_ops *ops = info->ops;
1916         int err;
1917
1918         expr->ops = ops;
1919         if (ops->init) {
1920                 err = ops->init(ctx, expr, (const struct nlattr **)info->tb);
1921                 if (err < 0)
1922                         goto err1;
1923         }
1924
1925         if (ops->validate) {
1926                 const struct nft_data *data = NULL;
1927
1928                 err = ops->validate(ctx, expr, &data);
1929                 if (err < 0)
1930                         goto err2;
1931         }
1932
1933         return 0;
1934
1935 err2:
1936         if (ops->destroy)
1937                 ops->destroy(ctx, expr);
1938 err1:
1939         expr->ops = NULL;
1940         return err;
1941 }
1942
1943 static void nf_tables_expr_destroy(const struct nft_ctx *ctx,
1944                                    struct nft_expr *expr)
1945 {
1946         if (expr->ops->destroy)
1947                 expr->ops->destroy(ctx, expr);
1948         module_put(expr->ops->type->owner);
1949 }
1950
1951 struct nft_expr *nft_expr_init(const struct nft_ctx *ctx,
1952                                const struct nlattr *nla)
1953 {
1954         struct nft_expr_info info;
1955         struct nft_expr *expr;
1956         int err;
1957
1958         err = nf_tables_expr_parse(ctx, nla, &info);
1959         if (err < 0)
1960                 goto err_expr_parse;
1961
1962         err = -EOPNOTSUPP;
1963         if (!(info.ops->type->flags & NFT_EXPR_STATEFUL))
1964                 goto err_expr_stateful;
1965
1966         err = -ENOMEM;
1967         expr = kzalloc(info.ops->size, GFP_KERNEL);
1968         if (expr == NULL)
1969                 goto err_expr_stateful;
1970
1971         err = nf_tables_newexpr(ctx, &info, expr);
1972         if (err < 0)
1973                 goto err_expr_new;
1974
1975         return expr;
1976 err_expr_new:
1977         kfree(expr);
1978 err_expr_stateful:
1979         module_put(info.ops->type->owner);
1980 err_expr_parse:
1981         return ERR_PTR(err);
1982 }
1983
1984 void nft_expr_destroy(const struct nft_ctx *ctx, struct nft_expr *expr)
1985 {
1986         nf_tables_expr_destroy(ctx, expr);
1987         kfree(expr);
1988 }
1989
1990 /*
1991  * Rules
1992  */
1993
1994 static struct nft_rule *__nf_tables_rule_lookup(const struct nft_chain *chain,
1995                                                 u64 handle)
1996 {
1997         struct nft_rule *rule;
1998
1999         // FIXME: this sucks
2000         list_for_each_entry(rule, &chain->rules, list) {
2001                 if (handle == rule->handle)
2002                         return rule;
2003         }
2004
2005         return ERR_PTR(-ENOENT);
2006 }
2007
2008 static struct nft_rule *nf_tables_rule_lookup(const struct nft_chain *chain,
2009                                               const struct nlattr *nla)
2010 {
2011         if (nla == NULL)
2012                 return ERR_PTR(-EINVAL);
2013
2014         return __nf_tables_rule_lookup(chain, be64_to_cpu(nla_get_be64(nla)));
2015 }
2016
2017 static const struct nla_policy nft_rule_policy[NFTA_RULE_MAX + 1] = {
2018         [NFTA_RULE_TABLE]       = { .type = NLA_STRING,
2019                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
2020         [NFTA_RULE_CHAIN]       = { .type = NLA_STRING,
2021                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
2022         [NFTA_RULE_HANDLE]      = { .type = NLA_U64 },
2023         [NFTA_RULE_EXPRESSIONS] = { .type = NLA_NESTED },
2024         [NFTA_RULE_COMPAT]      = { .type = NLA_NESTED },
2025         [NFTA_RULE_POSITION]    = { .type = NLA_U64 },
2026         [NFTA_RULE_USERDATA]    = { .type = NLA_BINARY,
2027                                     .len = NFT_USERDATA_MAXLEN },
2028         [NFTA_RULE_ID]          = { .type = NLA_U32 },
2029 };
2030
2031 static int nf_tables_fill_rule_info(struct sk_buff *skb, struct net *net,
2032                                     u32 portid, u32 seq, int event,
2033                                     u32 flags, int family,
2034                                     const struct nft_table *table,
2035                                     const struct nft_chain *chain,
2036                                     const struct nft_rule *rule)
2037 {
2038         struct nlmsghdr *nlh;
2039         struct nfgenmsg *nfmsg;
2040         const struct nft_expr *expr, *next;
2041         struct nlattr *list;
2042         const struct nft_rule *prule;
2043         u16 type = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
2044
2045         nlh = nlmsg_put(skb, portid, seq, type, sizeof(struct nfgenmsg), flags);
2046         if (nlh == NULL)
2047                 goto nla_put_failure;
2048
2049         nfmsg = nlmsg_data(nlh);
2050         nfmsg->nfgen_family     = family;
2051         nfmsg->version          = NFNETLINK_V0;
2052         nfmsg->res_id           = htons(net->nft.base_seq & 0xffff);
2053
2054         if (nla_put_string(skb, NFTA_RULE_TABLE, table->name))
2055                 goto nla_put_failure;
2056         if (nla_put_string(skb, NFTA_RULE_CHAIN, chain->name))
2057                 goto nla_put_failure;
2058         if (nla_put_be64(skb, NFTA_RULE_HANDLE, cpu_to_be64(rule->handle),
2059                          NFTA_RULE_PAD))
2060                 goto nla_put_failure;
2061
2062         if ((event != NFT_MSG_DELRULE) && (rule->list.prev != &chain->rules)) {
2063                 prule = list_prev_entry(rule, list);
2064                 if (nla_put_be64(skb, NFTA_RULE_POSITION,
2065                                  cpu_to_be64(prule->handle),
2066                                  NFTA_RULE_PAD))
2067                         goto nla_put_failure;
2068         }
2069
2070         list = nla_nest_start(skb, NFTA_RULE_EXPRESSIONS);
2071         if (list == NULL)
2072                 goto nla_put_failure;
2073         nft_rule_for_each_expr(expr, next, rule) {
2074                 if (nft_expr_dump(skb, NFTA_LIST_ELEM, expr) < 0)
2075                         goto nla_put_failure;
2076         }
2077         nla_nest_end(skb, list);
2078
2079         if (rule->udata) {
2080                 struct nft_userdata *udata = nft_userdata(rule);
2081                 if (nla_put(skb, NFTA_RULE_USERDATA, udata->len + 1,
2082                             udata->data) < 0)
2083                         goto nla_put_failure;
2084         }
2085
2086         nlmsg_end(skb, nlh);
2087         return 0;
2088
2089 nla_put_failure:
2090         nlmsg_trim(skb, nlh);
2091         return -1;
2092 }
2093
2094 static void nf_tables_rule_notify(const struct nft_ctx *ctx,
2095                                   const struct nft_rule *rule, int event)
2096 {
2097         struct sk_buff *skb;
2098         int err;
2099
2100         if (!ctx->report &&
2101             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
2102                 return;
2103
2104         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
2105         if (skb == NULL)
2106                 goto err;
2107
2108         err = nf_tables_fill_rule_info(skb, ctx->net, ctx->portid, ctx->seq,
2109                                        event, 0, ctx->afi->family, ctx->table,
2110                                        ctx->chain, rule);
2111         if (err < 0) {
2112                 kfree_skb(skb);
2113                 goto err;
2114         }
2115
2116         nfnetlink_send(skb, ctx->net, ctx->portid, NFNLGRP_NFTABLES,
2117                        ctx->report, GFP_KERNEL);
2118         return;
2119 err:
2120         nfnetlink_set_err(ctx->net, ctx->portid, NFNLGRP_NFTABLES, -ENOBUFS);
2121 }
2122
2123 struct nft_rule_dump_ctx {
2124         char *table;
2125         char *chain;
2126 };
2127
2128 static int nf_tables_dump_rules(struct sk_buff *skb,
2129                                 struct netlink_callback *cb)
2130 {
2131         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
2132         const struct nft_rule_dump_ctx *ctx = cb->data;
2133         const struct nft_af_info *afi;
2134         const struct nft_table *table;
2135         const struct nft_chain *chain;
2136         const struct nft_rule *rule;
2137         unsigned int idx = 0, s_idx = cb->args[0];
2138         struct net *net = sock_net(skb->sk);
2139         int family = nfmsg->nfgen_family;
2140
2141         rcu_read_lock();
2142         cb->seq = net->nft.base_seq;
2143
2144         list_for_each_entry_rcu(afi, &net->nft.af_info, list) {
2145                 if (family != NFPROTO_UNSPEC && family != afi->family)
2146                         continue;
2147
2148                 list_for_each_entry_rcu(table, &afi->tables, list) {
2149                         if (ctx && ctx->table &&
2150                             strcmp(ctx->table, table->name) != 0)
2151                                 continue;
2152
2153                         list_for_each_entry_rcu(chain, &table->chains, list) {
2154                                 if (ctx && ctx->chain &&
2155                                     strcmp(ctx->chain, chain->name) != 0)
2156                                         continue;
2157
2158                                 list_for_each_entry_rcu(rule, &chain->rules, list) {
2159                                         if (!nft_is_active(net, rule))
2160                                                 goto cont;
2161                                         if (idx < s_idx)
2162                                                 goto cont;
2163                                         if (idx > s_idx)
2164                                                 memset(&cb->args[1], 0,
2165                                                        sizeof(cb->args) - sizeof(cb->args[0]));
2166                                         if (nf_tables_fill_rule_info(skb, net, NETLINK_CB(cb->skb).portid,
2167                                                                       cb->nlh->nlmsg_seq,
2168                                                                       NFT_MSG_NEWRULE,
2169                                                                       NLM_F_MULTI | NLM_F_APPEND,
2170                                                                       afi->family, table, chain, rule) < 0)
2171                                                 goto done;
2172
2173                                         nl_dump_check_consistent(cb, nlmsg_hdr(skb));
2174 cont:
2175                                         idx++;
2176                                 }
2177                         }
2178                 }
2179         }
2180 done:
2181         rcu_read_unlock();
2182
2183         cb->args[0] = idx;
2184         return skb->len;
2185 }
2186
2187 static int nf_tables_dump_rules_done(struct netlink_callback *cb)
2188 {
2189         struct nft_rule_dump_ctx *ctx = cb->data;
2190
2191         if (ctx) {
2192                 kfree(ctx->table);
2193                 kfree(ctx->chain);
2194                 kfree(ctx);
2195         }
2196         return 0;
2197 }
2198
2199 static int nf_tables_getrule(struct net *net, struct sock *nlsk,
2200                              struct sk_buff *skb, const struct nlmsghdr *nlh,
2201                              const struct nlattr * const nla[],
2202                              struct netlink_ext_ack *extack)
2203 {
2204         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2205         u8 genmask = nft_genmask_cur(net);
2206         const struct nft_af_info *afi;
2207         const struct nft_table *table;
2208         const struct nft_chain *chain;
2209         const struct nft_rule *rule;
2210         struct sk_buff *skb2;
2211         int family = nfmsg->nfgen_family;
2212         int err;
2213
2214         if (nlh->nlmsg_flags & NLM_F_DUMP) {
2215                 struct netlink_dump_control c = {
2216                         .dump = nf_tables_dump_rules,
2217                         .done = nf_tables_dump_rules_done,
2218                 };
2219
2220                 if (nla[NFTA_RULE_TABLE] || nla[NFTA_RULE_CHAIN]) {
2221                         struct nft_rule_dump_ctx *ctx;
2222
2223                         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
2224                         if (!ctx)
2225                                 return -ENOMEM;
2226
2227                         if (nla[NFTA_RULE_TABLE]) {
2228                                 ctx->table = nla_strdup(nla[NFTA_RULE_TABLE],
2229                                                         GFP_KERNEL);
2230                                 if (!ctx->table) {
2231                                         kfree(ctx);
2232                                         return -ENOMEM;
2233                                 }
2234                         }
2235                         if (nla[NFTA_RULE_CHAIN]) {
2236                                 ctx->chain = nla_strdup(nla[NFTA_RULE_CHAIN],
2237                                                         GFP_KERNEL);
2238                                 if (!ctx->chain) {
2239                                         kfree(ctx->table);
2240                                         kfree(ctx);
2241                                         return -ENOMEM;
2242                                 }
2243                         }
2244                         c.data = ctx;
2245                 }
2246
2247                 return netlink_dump_start(nlsk, skb, nlh, &c);
2248         }
2249
2250         afi = nf_tables_afinfo_lookup(net, family, false);
2251         if (IS_ERR(afi))
2252                 return PTR_ERR(afi);
2253
2254         table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE], genmask);
2255         if (IS_ERR(table))
2256                 return PTR_ERR(table);
2257
2258         chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN], genmask);
2259         if (IS_ERR(chain))
2260                 return PTR_ERR(chain);
2261
2262         rule = nf_tables_rule_lookup(chain, nla[NFTA_RULE_HANDLE]);
2263         if (IS_ERR(rule))
2264                 return PTR_ERR(rule);
2265
2266         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2267         if (!skb2)
2268                 return -ENOMEM;
2269
2270         err = nf_tables_fill_rule_info(skb2, net, NETLINK_CB(skb).portid,
2271                                        nlh->nlmsg_seq, NFT_MSG_NEWRULE, 0,
2272                                        family, table, chain, rule);
2273         if (err < 0)
2274                 goto err;
2275
2276         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
2277
2278 err:
2279         kfree_skb(skb2);
2280         return err;
2281 }
2282
2283 static void nf_tables_rule_destroy(const struct nft_ctx *ctx,
2284                                    struct nft_rule *rule)
2285 {
2286         struct nft_expr *expr, *next;
2287
2288         /*
2289          * Careful: some expressions might not be initialized in case this
2290          * is called on error from nf_tables_newrule().
2291          */
2292         expr = nft_expr_first(rule);
2293         while (expr != nft_expr_last(rule) && expr->ops) {
2294                 next = nft_expr_next(expr);
2295                 nf_tables_expr_destroy(ctx, expr);
2296                 expr = next;
2297         }
2298         kfree(rule);
2299 }
2300
2301 static void nf_tables_rule_release(const struct nft_ctx *ctx,
2302                                    struct nft_rule *rule)
2303 {
2304         nft_rule_expr_deactivate(ctx, rule, NFT_TRANS_RELEASE);
2305         nf_tables_rule_destroy(ctx, rule);
2306 }
2307
2308 #define NFT_RULE_MAXEXPRS       128
2309
2310 static struct nft_expr_info *info;
2311
2312 static int nf_tables_newrule(struct net *net, struct sock *nlsk,
2313                              struct sk_buff *skb, const struct nlmsghdr *nlh,
2314                              const struct nlattr * const nla[],
2315                              struct netlink_ext_ack *extack)
2316 {
2317         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2318         u8 genmask = nft_genmask_next(net);
2319         struct nft_af_info *afi;
2320         struct nft_table *table;
2321         struct nft_chain *chain;
2322         struct nft_rule *rule, *old_rule = NULL;
2323         struct nft_userdata *udata;
2324         struct nft_trans *trans = NULL;
2325         struct nft_expr *expr;
2326         struct nft_ctx ctx;
2327         struct nlattr *tmp;
2328         unsigned int size, i, n, ulen = 0, usize = 0;
2329         int err, rem;
2330         bool create;
2331         u64 handle, pos_handle;
2332
2333         create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false;
2334
2335         afi = nf_tables_afinfo_lookup(net, nfmsg->nfgen_family, create);
2336         if (IS_ERR(afi))
2337                 return PTR_ERR(afi);
2338
2339         table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE], genmask);
2340         if (IS_ERR(table))
2341                 return PTR_ERR(table);
2342
2343         chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN], genmask);
2344         if (IS_ERR(chain))
2345                 return PTR_ERR(chain);
2346
2347         if (nla[NFTA_RULE_HANDLE]) {
2348                 handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_HANDLE]));
2349                 rule = __nf_tables_rule_lookup(chain, handle);
2350                 if (IS_ERR(rule))
2351                         return PTR_ERR(rule);
2352
2353                 if (nlh->nlmsg_flags & NLM_F_EXCL)
2354                         return -EEXIST;
2355                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
2356                         old_rule = rule;
2357                 else
2358                         return -EOPNOTSUPP;
2359         } else {
2360                 if (!create || nlh->nlmsg_flags & NLM_F_REPLACE)
2361                         return -EINVAL;
2362                 handle = nf_tables_alloc_handle(table);
2363
2364                 if (chain->use == UINT_MAX)
2365                         return -EOVERFLOW;
2366         }
2367
2368         if (nla[NFTA_RULE_POSITION]) {
2369                 if (!(nlh->nlmsg_flags & NLM_F_CREATE))
2370                         return -EOPNOTSUPP;
2371
2372                 pos_handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_POSITION]));
2373                 old_rule = __nf_tables_rule_lookup(chain, pos_handle);
2374                 if (IS_ERR(old_rule))
2375                         return PTR_ERR(old_rule);
2376         }
2377
2378         nft_ctx_init(&ctx, net, skb, nlh, afi, table, chain, nla);
2379
2380         n = 0;
2381         size = 0;
2382         if (nla[NFTA_RULE_EXPRESSIONS]) {
2383                 nla_for_each_nested(tmp, nla[NFTA_RULE_EXPRESSIONS], rem) {
2384                         err = -EINVAL;
2385                         if (nla_type(tmp) != NFTA_LIST_ELEM)
2386                                 goto err1;
2387                         if (n == NFT_RULE_MAXEXPRS)
2388                                 goto err1;
2389                         err = nf_tables_expr_parse(&ctx, tmp, &info[n]);
2390                         if (err < 0)
2391                                 goto err1;
2392                         size += info[n].ops->size;
2393                         n++;
2394                 }
2395         }
2396         /* Check for overflow of dlen field */
2397         err = -EFBIG;
2398         if (size >= 1 << 12)
2399                 goto err1;
2400
2401         if (nla[NFTA_RULE_USERDATA]) {
2402                 ulen = nla_len(nla[NFTA_RULE_USERDATA]);
2403                 if (ulen > 0)
2404                         usize = sizeof(struct nft_userdata) + ulen;
2405         }
2406
2407         err = -ENOMEM;
2408         rule = kzalloc(sizeof(*rule) + size + usize, GFP_KERNEL);
2409         if (rule == NULL)
2410                 goto err1;
2411
2412         nft_activate_next(net, rule);
2413
2414         rule->handle = handle;
2415         rule->dlen   = size;
2416         rule->udata  = ulen ? 1 : 0;
2417
2418         if (ulen) {
2419                 udata = nft_userdata(rule);
2420                 udata->len = ulen - 1;
2421                 nla_memcpy(udata->data, nla[NFTA_RULE_USERDATA], ulen);
2422         }
2423
2424         expr = nft_expr_first(rule);
2425         for (i = 0; i < n; i++) {
2426                 err = nf_tables_newexpr(&ctx, &info[i], expr);
2427                 if (err < 0)
2428                         goto err2;
2429                 info[i].ops = NULL;
2430                 expr = nft_expr_next(expr);
2431         }
2432
2433         if (nlh->nlmsg_flags & NLM_F_REPLACE) {
2434                 trans = nft_trans_rule_add(&ctx, NFT_MSG_NEWRULE, rule);
2435                 if (trans == NULL) {
2436                         err = -ENOMEM;
2437                         goto err2;
2438                 }
2439                 err = nft_delrule(&ctx, old_rule);
2440                 if (err < 0) {
2441                         nft_trans_destroy(trans);
2442                         goto err2;
2443                 }
2444
2445                 list_add_tail_rcu(&rule->list, &old_rule->list);
2446         } else {
2447                 if (nft_trans_rule_add(&ctx, NFT_MSG_NEWRULE, rule) == NULL) {
2448                         err = -ENOMEM;
2449                         goto err2;
2450                 }
2451
2452                 if (nlh->nlmsg_flags & NLM_F_APPEND) {
2453                         if (old_rule)
2454                                 list_add_rcu(&rule->list, &old_rule->list);
2455                         else
2456                                 list_add_tail_rcu(&rule->list, &chain->rules);
2457                  } else {
2458                         if (old_rule)
2459                                 list_add_tail_rcu(&rule->list, &old_rule->list);
2460                         else
2461                                 list_add_rcu(&rule->list, &chain->rules);
2462                 }
2463         }
2464         chain->use++;
2465         return 0;
2466
2467 err2:
2468         nf_tables_rule_release(&ctx, rule);
2469 err1:
2470         for (i = 0; i < n; i++) {
2471                 if (info[i].ops != NULL)
2472                         module_put(info[i].ops->type->owner);
2473         }
2474         return err;
2475 }
2476
2477 static struct nft_rule *nft_rule_lookup_byid(const struct net *net,
2478                                              const struct nft_chain *chain,
2479                                              const struct nlattr *nla)
2480 {
2481         u32 id = ntohl(nla_get_be32(nla));
2482         struct nft_trans *trans;
2483
2484         list_for_each_entry(trans, &net->nft.commit_list, list) {
2485                 struct nft_rule *rule = nft_trans_rule(trans);
2486
2487                 if (trans->msg_type == NFT_MSG_NEWRULE &&
2488                     trans->ctx.chain == chain &&
2489                     id == nft_trans_rule_id(trans))
2490                         return rule;
2491         }
2492         return ERR_PTR(-ENOENT);
2493 }
2494
2495 static int nf_tables_delrule(struct net *net, struct sock *nlsk,
2496                              struct sk_buff *skb, const struct nlmsghdr *nlh,
2497                              const struct nlattr * const nla[],
2498                              struct netlink_ext_ack *extack)
2499 {
2500         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2501         u8 genmask = nft_genmask_next(net);
2502         struct nft_af_info *afi;
2503         struct nft_table *table;
2504         struct nft_chain *chain = NULL;
2505         struct nft_rule *rule;
2506         int family = nfmsg->nfgen_family, err = 0;
2507         struct nft_ctx ctx;
2508
2509         afi = nf_tables_afinfo_lookup(net, family, false);
2510         if (IS_ERR(afi))
2511                 return PTR_ERR(afi);
2512
2513         table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE], genmask);
2514         if (IS_ERR(table))
2515                 return PTR_ERR(table);
2516
2517         if (nla[NFTA_RULE_CHAIN]) {
2518                 chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN],
2519                                                genmask);
2520                 if (IS_ERR(chain))
2521                         return PTR_ERR(chain);
2522         }
2523
2524         nft_ctx_init(&ctx, net, skb, nlh, afi, table, chain, nla);
2525
2526         if (chain) {
2527                 if (nla[NFTA_RULE_HANDLE]) {
2528                         rule = nf_tables_rule_lookup(chain,
2529                                                      nla[NFTA_RULE_HANDLE]);
2530                         if (IS_ERR(rule))
2531                                 return PTR_ERR(rule);
2532
2533                         err = nft_delrule(&ctx, rule);
2534                 } else if (nla[NFTA_RULE_ID]) {
2535                         rule = nft_rule_lookup_byid(net, chain, nla[NFTA_RULE_ID]);
2536                         if (IS_ERR(rule))
2537                                 return PTR_ERR(rule);
2538
2539                         err = nft_delrule(&ctx, rule);
2540                 } else {
2541                         err = nft_delrule_by_chain(&ctx);
2542                 }
2543         } else {
2544                 list_for_each_entry(chain, &table->chains, list) {
2545                         if (!nft_is_active_next(net, chain))
2546                                 continue;
2547
2548                         ctx.chain = chain;
2549                         err = nft_delrule_by_chain(&ctx);
2550                         if (err < 0)
2551                                 break;
2552                 }
2553         }
2554
2555         return err;
2556 }
2557
2558 /*
2559  * Sets
2560  */
2561
2562 static LIST_HEAD(nf_tables_set_types);
2563
2564 int nft_register_set(struct nft_set_type *type)
2565 {
2566         nfnl_lock(NFNL_SUBSYS_NFTABLES);
2567         list_add_tail_rcu(&type->list, &nf_tables_set_types);
2568         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
2569         return 0;
2570 }
2571 EXPORT_SYMBOL_GPL(nft_register_set);
2572
2573 void nft_unregister_set(struct nft_set_type *type)
2574 {
2575         nfnl_lock(NFNL_SUBSYS_NFTABLES);
2576         list_del_rcu(&type->list);
2577         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
2578 }
2579 EXPORT_SYMBOL_GPL(nft_unregister_set);
2580
2581 #define NFT_SET_FEATURES        (NFT_SET_INTERVAL | NFT_SET_MAP | \
2582                                  NFT_SET_TIMEOUT | NFT_SET_OBJECT)
2583
2584 static bool nft_set_ops_candidate(const struct nft_set_ops *ops, u32 flags)
2585 {
2586         return (flags & ops->features) == (flags & NFT_SET_FEATURES);
2587 }
2588
2589 /*
2590  * Select a set implementation based on the data characteristics and the
2591  * given policy. The total memory use might not be known if no size is
2592  * given, in that case the amount of memory per element is used.
2593  */
2594 static const struct nft_set_ops *
2595 nft_select_set_ops(const struct nft_ctx *ctx,
2596                    const struct nlattr * const nla[],
2597                    const struct nft_set_desc *desc,
2598                    enum nft_set_policies policy)
2599 {
2600         const struct nft_set_ops *ops, *bops;
2601         struct nft_set_estimate est, best;
2602         const struct nft_set_type *type;
2603         u32 flags = 0;
2604
2605 #ifdef CONFIG_MODULES
2606         if (list_empty(&nf_tables_set_types)) {
2607                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
2608                 request_module("nft-set");
2609                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
2610                 if (!list_empty(&nf_tables_set_types))
2611                         return ERR_PTR(-EAGAIN);
2612         }
2613 #endif
2614         if (nla[NFTA_SET_FLAGS] != NULL)
2615                 flags = ntohl(nla_get_be32(nla[NFTA_SET_FLAGS]));
2616
2617         bops        = NULL;
2618         best.size   = ~0;
2619         best.lookup = ~0;
2620         best.space  = ~0;
2621
2622         list_for_each_entry(type, &nf_tables_set_types, list) {
2623                 if (!type->select_ops)
2624                         ops = type->ops;
2625                 else
2626                         ops = type->select_ops(ctx, desc, flags);
2627                 if (!ops)
2628                         continue;
2629
2630                 if (!nft_set_ops_candidate(ops, flags))
2631                         continue;
2632                 if (!ops->estimate(desc, flags, &est))
2633                         continue;
2634
2635                 switch (policy) {
2636                 case NFT_SET_POL_PERFORMANCE:
2637                         if (est.lookup < best.lookup)
2638                                 break;
2639                         if (est.lookup == best.lookup) {
2640                                 if (!desc->size) {
2641                                         if (est.space < best.space)
2642                                                 break;
2643                                 } else if (est.size < best.size) {
2644                                         break;
2645                                 }
2646                         }
2647                         continue;
2648                 case NFT_SET_POL_MEMORY:
2649                         if (!desc->size) {
2650                                 if (est.space < best.space)
2651                                         break;
2652                                 if (est.space == best.space &&
2653                                     est.lookup < best.lookup)
2654                                         break;
2655                         } else if (est.size < best.size) {
2656                                 break;
2657                         }
2658                         continue;
2659                 default:
2660                         break;
2661                 }
2662
2663                 if (!try_module_get(type->owner))
2664                         continue;
2665                 if (bops != NULL)
2666                         module_put(bops->type->owner);
2667
2668                 bops = ops;
2669                 best = est;
2670         }
2671
2672         if (bops != NULL)
2673                 return bops;
2674
2675         return ERR_PTR(-EOPNOTSUPP);
2676 }
2677
2678 static const struct nla_policy nft_set_policy[NFTA_SET_MAX + 1] = {
2679         [NFTA_SET_TABLE]                = { .type = NLA_STRING,
2680                                             .len = NFT_TABLE_MAXNAMELEN - 1 },
2681         [NFTA_SET_NAME]                 = { .type = NLA_STRING,
2682                                             .len = NFT_SET_MAXNAMELEN - 1 },
2683         [NFTA_SET_FLAGS]                = { .type = NLA_U32 },
2684         [NFTA_SET_KEY_TYPE]             = { .type = NLA_U32 },
2685         [NFTA_SET_KEY_LEN]              = { .type = NLA_U32 },
2686         [NFTA_SET_DATA_TYPE]            = { .type = NLA_U32 },
2687         [NFTA_SET_DATA_LEN]             = { .type = NLA_U32 },
2688         [NFTA_SET_POLICY]               = { .type = NLA_U32 },
2689         [NFTA_SET_DESC]                 = { .type = NLA_NESTED },
2690         [NFTA_SET_ID]                   = { .type = NLA_U32 },
2691         [NFTA_SET_TIMEOUT]              = { .type = NLA_U64 },
2692         [NFTA_SET_GC_INTERVAL]          = { .type = NLA_U32 },
2693         [NFTA_SET_USERDATA]             = { .type = NLA_BINARY,
2694                                             .len  = NFT_USERDATA_MAXLEN },
2695         [NFTA_SET_OBJ_TYPE]             = { .type = NLA_U32 },
2696 };
2697
2698 static const struct nla_policy nft_set_desc_policy[NFTA_SET_DESC_MAX + 1] = {
2699         [NFTA_SET_DESC_SIZE]            = { .type = NLA_U32 },
2700 };
2701
2702 static int nft_ctx_init_from_setattr(struct nft_ctx *ctx, struct net *net,
2703                                      const struct sk_buff *skb,
2704                                      const struct nlmsghdr *nlh,
2705                                      const struct nlattr * const nla[],
2706                                      u8 genmask)
2707 {
2708         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2709         struct nft_af_info *afi = NULL;
2710         struct nft_table *table = NULL;
2711
2712         if (nfmsg->nfgen_family != NFPROTO_UNSPEC) {
2713                 afi = nf_tables_afinfo_lookup(net, nfmsg->nfgen_family, false);
2714                 if (IS_ERR(afi))
2715                         return PTR_ERR(afi);
2716         }
2717
2718         if (nla[NFTA_SET_TABLE] != NULL) {
2719                 if (afi == NULL)
2720                         return -EAFNOSUPPORT;
2721
2722                 table = nf_tables_table_lookup(afi, nla[NFTA_SET_TABLE],
2723                                                genmask);
2724                 if (IS_ERR(table))
2725                         return PTR_ERR(table);
2726         }
2727
2728         nft_ctx_init(ctx, net, skb, nlh, afi, table, NULL, nla);
2729         return 0;
2730 }
2731
2732 static struct nft_set *nf_tables_set_lookup(const struct nft_table *table,
2733                                             const struct nlattr *nla, u8 genmask)
2734 {
2735         struct nft_set *set;
2736
2737         if (nla == NULL)
2738                 return ERR_PTR(-EINVAL);
2739
2740         list_for_each_entry(set, &table->sets, list) {
2741                 if (!nla_strcmp(nla, set->name) &&
2742                     nft_active_genmask(set, genmask))
2743                         return set;
2744         }
2745         return ERR_PTR(-ENOENT);
2746 }
2747
2748 static struct nft_set *nf_tables_set_lookup_byid(const struct net *net,
2749                                                  const struct nft_table *table,
2750                                                  const struct nlattr *nla,
2751                                                  u8 genmask)
2752 {
2753         struct nft_trans *trans;
2754         u32 id = ntohl(nla_get_be32(nla));
2755
2756         list_for_each_entry(trans, &net->nft.commit_list, list) {
2757                 if (trans->msg_type == NFT_MSG_NEWSET) {
2758                         struct nft_set *set = nft_trans_set(trans);
2759
2760                         if (id == nft_trans_set_id(trans) &&
2761                             set->table == table &&
2762                             nft_active_genmask(set, genmask))
2763                                 return set;
2764                 }
2765         }
2766         return ERR_PTR(-ENOENT);
2767 }
2768
2769 struct nft_set *nft_set_lookup(const struct net *net,
2770                                const struct nft_table *table,
2771                                const struct nlattr *nla_set_name,
2772                                const struct nlattr *nla_set_id,
2773                                u8 genmask)
2774 {
2775         struct nft_set *set;
2776
2777         set = nf_tables_set_lookup(table, nla_set_name, genmask);
2778         if (IS_ERR(set)) {
2779                 if (!nla_set_id)
2780                         return set;
2781
2782                 set = nf_tables_set_lookup_byid(net, table, nla_set_id, genmask);
2783         }
2784         return set;
2785 }
2786 EXPORT_SYMBOL_GPL(nft_set_lookup);
2787
2788 static int nf_tables_set_alloc_name(struct nft_ctx *ctx, struct nft_set *set,
2789                                     const char *name)
2790 {
2791         const struct nft_set *i;
2792         const char *p;
2793         unsigned long *inuse;
2794         unsigned int n = 0, min = 0;
2795
2796         p = strchr(name, '%');
2797         if (p != NULL) {
2798                 if (p[1] != 'd' || strchr(p + 2, '%'))
2799                         return -EINVAL;
2800
2801                 inuse = (unsigned long *)get_zeroed_page(GFP_KERNEL);
2802                 if (inuse == NULL)
2803                         return -ENOMEM;
2804 cont:
2805                 list_for_each_entry(i, &ctx->table->sets, list) {
2806                         int tmp;
2807
2808                         if (!nft_is_active_next(ctx->net, i))
2809                                 continue;
2810                         if (!sscanf(i->name, name, &tmp))
2811                                 continue;
2812                         if (tmp < min || tmp >= min + BITS_PER_BYTE * PAGE_SIZE)
2813                                 continue;
2814
2815                         set_bit(tmp - min, inuse);
2816                 }
2817
2818                 n = find_first_zero_bit(inuse, BITS_PER_BYTE * PAGE_SIZE);
2819                 if (n >= BITS_PER_BYTE * PAGE_SIZE) {
2820                         min += BITS_PER_BYTE * PAGE_SIZE;
2821                         memset(inuse, 0, PAGE_SIZE);
2822                         goto cont;
2823                 }
2824                 free_page((unsigned long)inuse);
2825         }
2826
2827         set->name = kasprintf(GFP_KERNEL, name, min + n);
2828         if (!set->name)
2829                 return -ENOMEM;
2830
2831         list_for_each_entry(i, &ctx->table->sets, list) {
2832                 if (!nft_is_active_next(ctx->net, i))
2833                         continue;
2834                 if (!strcmp(set->name, i->name)) {
2835                         kfree(set->name);
2836                         return -ENFILE;
2837                 }
2838         }
2839         return 0;
2840 }
2841
2842 static int nf_tables_fill_set(struct sk_buff *skb, const struct nft_ctx *ctx,
2843                               const struct nft_set *set, u16 event, u16 flags)
2844 {
2845         struct nfgenmsg *nfmsg;
2846         struct nlmsghdr *nlh;
2847         struct nlattr *desc;
2848         u32 portid = ctx->portid;
2849         u32 seq = ctx->seq;
2850
2851         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
2852         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg),
2853                         flags);
2854         if (nlh == NULL)
2855                 goto nla_put_failure;
2856
2857         nfmsg = nlmsg_data(nlh);
2858         nfmsg->nfgen_family     = ctx->afi->family;
2859         nfmsg->version          = NFNETLINK_V0;
2860         nfmsg->res_id           = htons(ctx->net->nft.base_seq & 0xffff);
2861
2862         if (nla_put_string(skb, NFTA_SET_TABLE, ctx->table->name))
2863                 goto nla_put_failure;
2864         if (nla_put_string(skb, NFTA_SET_NAME, set->name))
2865                 goto nla_put_failure;
2866         if (set->flags != 0)
2867                 if (nla_put_be32(skb, NFTA_SET_FLAGS, htonl(set->flags)))
2868                         goto nla_put_failure;
2869
2870         if (nla_put_be32(skb, NFTA_SET_KEY_TYPE, htonl(set->ktype)))
2871                 goto nla_put_failure;
2872         if (nla_put_be32(skb, NFTA_SET_KEY_LEN, htonl(set->klen)))
2873                 goto nla_put_failure;
2874         if (set->flags & NFT_SET_MAP) {
2875                 if (nla_put_be32(skb, NFTA_SET_DATA_TYPE, htonl(set->dtype)))
2876                         goto nla_put_failure;
2877                 if (nla_put_be32(skb, NFTA_SET_DATA_LEN, htonl(set->dlen)))
2878                         goto nla_put_failure;
2879         }
2880         if (set->flags & NFT_SET_OBJECT &&
2881             nla_put_be32(skb, NFTA_SET_OBJ_TYPE, htonl(set->objtype)))
2882                 goto nla_put_failure;
2883
2884         if (set->timeout &&
2885             nla_put_be64(skb, NFTA_SET_TIMEOUT,
2886                          cpu_to_be64(jiffies_to_msecs(set->timeout)),
2887                          NFTA_SET_PAD))
2888                 goto nla_put_failure;
2889         if (set->gc_int &&
2890             nla_put_be32(skb, NFTA_SET_GC_INTERVAL, htonl(set->gc_int)))
2891                 goto nla_put_failure;
2892
2893         if (set->policy != NFT_SET_POL_PERFORMANCE) {
2894                 if (nla_put_be32(skb, NFTA_SET_POLICY, htonl(set->policy)))
2895                         goto nla_put_failure;
2896         }
2897
2898         if (set->udata &&
2899             nla_put(skb, NFTA_SET_USERDATA, set->udlen, set->udata))
2900                 goto nla_put_failure;
2901
2902         desc = nla_nest_start(skb, NFTA_SET_DESC);
2903         if (desc == NULL)
2904                 goto nla_put_failure;
2905         if (set->size &&
2906             nla_put_be32(skb, NFTA_SET_DESC_SIZE, htonl(set->size)))
2907                 goto nla_put_failure;
2908         nla_nest_end(skb, desc);
2909
2910         nlmsg_end(skb, nlh);
2911         return 0;
2912
2913 nla_put_failure:
2914         nlmsg_trim(skb, nlh);
2915         return -1;
2916 }
2917
2918 static void nf_tables_set_notify(const struct nft_ctx *ctx,
2919                                  const struct nft_set *set, int event,
2920                                  gfp_t gfp_flags)
2921 {
2922         struct sk_buff *skb;
2923         u32 portid = ctx->portid;
2924         int err;
2925
2926         if (!ctx->report &&
2927             !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
2928                 return;
2929
2930         skb = nlmsg_new(NLMSG_GOODSIZE, gfp_flags);
2931         if (skb == NULL)
2932                 goto err;
2933
2934         err = nf_tables_fill_set(skb, ctx, set, event, 0);
2935         if (err < 0) {
2936                 kfree_skb(skb);
2937                 goto err;
2938         }
2939
2940         nfnetlink_send(skb, ctx->net, portid, NFNLGRP_NFTABLES, ctx->report,
2941                        gfp_flags);
2942         return;
2943 err:
2944         nfnetlink_set_err(ctx->net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
2945 }
2946
2947 static int nf_tables_dump_sets(struct sk_buff *skb, struct netlink_callback *cb)
2948 {
2949         const struct nft_set *set;
2950         unsigned int idx, s_idx = cb->args[0];
2951         struct nft_af_info *afi;
2952         struct nft_table *table, *cur_table = (struct nft_table *)cb->args[2];
2953         struct net *net = sock_net(skb->sk);
2954         int cur_family = cb->args[3];
2955         struct nft_ctx *ctx = cb->data, ctx_set;
2956
2957         if (cb->args[1])
2958                 return skb->len;
2959
2960         rcu_read_lock();
2961         cb->seq = net->nft.base_seq;
2962
2963         list_for_each_entry_rcu(afi, &net->nft.af_info, list) {
2964                 if (ctx->afi && ctx->afi != afi)
2965                         continue;
2966
2967                 if (cur_family) {
2968                         if (afi->family != cur_family)
2969                                 continue;
2970
2971                         cur_family = 0;
2972                 }
2973                 list_for_each_entry_rcu(table, &afi->tables, list) {
2974                         if (ctx->table && ctx->table != table)
2975                                 continue;
2976
2977                         if (cur_table) {
2978                                 if (cur_table != table)
2979                                         continue;
2980
2981                                 cur_table = NULL;
2982                         }
2983                         idx = 0;
2984                         list_for_each_entry_rcu(set, &table->sets, list) {
2985                                 if (idx < s_idx)
2986                                         goto cont;
2987                                 if (!nft_is_active(net, set))
2988                                         goto cont;
2989
2990                                 ctx_set = *ctx;
2991                                 ctx_set.table = table;
2992                                 ctx_set.afi = afi;
2993                                 if (nf_tables_fill_set(skb, &ctx_set, set,
2994                                                        NFT_MSG_NEWSET,
2995                                                        NLM_F_MULTI) < 0) {
2996                                         cb->args[0] = idx;
2997                                         cb->args[2] = (unsigned long) table;
2998                                         cb->args[3] = afi->family;
2999                                         goto done;
3000                                 }
3001                                 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
3002 cont:
3003                                 idx++;
3004                         }
3005                         if (s_idx)
3006                                 s_idx = 0;
3007                 }
3008         }
3009         cb->args[1] = 1;
3010 done:
3011         rcu_read_unlock();
3012         return skb->len;
3013 }
3014
3015 static int nf_tables_dump_sets_done(struct netlink_callback *cb)
3016 {
3017         kfree(cb->data);
3018         return 0;
3019 }
3020
3021 static int nf_tables_getset(struct net *net, struct sock *nlsk,
3022                             struct sk_buff *skb, const struct nlmsghdr *nlh,
3023                             const struct nlattr * const nla[],
3024                             struct netlink_ext_ack *extack)
3025 {
3026         u8 genmask = nft_genmask_cur(net);
3027         const struct nft_set *set;
3028         struct nft_ctx ctx;
3029         struct sk_buff *skb2;
3030         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
3031         int err;
3032
3033         /* Verify existence before starting dump */
3034         err = nft_ctx_init_from_setattr(&ctx, net, skb, nlh, nla, genmask);
3035         if (err < 0)
3036                 return err;
3037
3038         if (nlh->nlmsg_flags & NLM_F_DUMP) {
3039                 struct netlink_dump_control c = {
3040                         .dump = nf_tables_dump_sets,
3041                         .done = nf_tables_dump_sets_done,
3042                 };
3043                 struct nft_ctx *ctx_dump;
3044
3045                 ctx_dump = kmalloc(sizeof(*ctx_dump), GFP_KERNEL);
3046                 if (ctx_dump == NULL)
3047                         return -ENOMEM;
3048
3049                 *ctx_dump = ctx;
3050                 c.data = ctx_dump;
3051
3052                 return netlink_dump_start(nlsk, skb, nlh, &c);
3053         }
3054
3055         /* Only accept unspec with dump */
3056         if (nfmsg->nfgen_family == NFPROTO_UNSPEC)
3057                 return -EAFNOSUPPORT;
3058         if (!nla[NFTA_SET_TABLE])
3059                 return -EINVAL;
3060
3061         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME], genmask);
3062         if (IS_ERR(set))
3063                 return PTR_ERR(set);
3064
3065         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
3066         if (skb2 == NULL)
3067                 return -ENOMEM;
3068
3069         err = nf_tables_fill_set(skb2, &ctx, set, NFT_MSG_NEWSET, 0);
3070         if (err < 0)
3071                 goto err;
3072
3073         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
3074
3075 err:
3076         kfree_skb(skb2);
3077         return err;
3078 }
3079
3080 static int nf_tables_set_desc_parse(const struct nft_ctx *ctx,
3081                                     struct nft_set_desc *desc,
3082                                     const struct nlattr *nla)
3083 {
3084         struct nlattr *da[NFTA_SET_DESC_MAX + 1];
3085         int err;
3086
3087         err = nla_parse_nested(da, NFTA_SET_DESC_MAX, nla,
3088                                nft_set_desc_policy, NULL);
3089         if (err < 0)
3090                 return err;
3091
3092         if (da[NFTA_SET_DESC_SIZE] != NULL)
3093                 desc->size = ntohl(nla_get_be32(da[NFTA_SET_DESC_SIZE]));
3094
3095         return 0;
3096 }
3097
3098 static int nf_tables_newset(struct net *net, struct sock *nlsk,
3099                             struct sk_buff *skb, const struct nlmsghdr *nlh,
3100                             const struct nlattr * const nla[],
3101                             struct netlink_ext_ack *extack)
3102 {
3103         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
3104         u8 genmask = nft_genmask_next(net);
3105         const struct nft_set_ops *ops;
3106         struct nft_af_info *afi;
3107         struct nft_table *table;
3108         struct nft_set *set;
3109         struct nft_ctx ctx;
3110         char *name;
3111         unsigned int size;
3112         bool create;
3113         u64 timeout;
3114         u32 ktype, dtype, flags, policy, gc_int, objtype;
3115         struct nft_set_desc desc;
3116         unsigned char *udata;
3117         u16 udlen;
3118         int err;
3119
3120         if (nla[NFTA_SET_TABLE] == NULL ||
3121             nla[NFTA_SET_NAME] == NULL ||
3122             nla[NFTA_SET_KEY_LEN] == NULL ||
3123             nla[NFTA_SET_ID] == NULL)
3124                 return -EINVAL;
3125
3126         memset(&desc, 0, sizeof(desc));
3127
3128         ktype = NFT_DATA_VALUE;
3129         if (nla[NFTA_SET_KEY_TYPE] != NULL) {
3130                 ktype = ntohl(nla_get_be32(nla[NFTA_SET_KEY_TYPE]));
3131                 if ((ktype & NFT_DATA_RESERVED_MASK) == NFT_DATA_RESERVED_MASK)
3132                         return -EINVAL;
3133         }
3134
3135         desc.klen = ntohl(nla_get_be32(nla[NFTA_SET_KEY_LEN]));
3136         if (desc.klen == 0 || desc.klen > NFT_DATA_VALUE_MAXLEN)
3137                 return -EINVAL;
3138
3139         flags = 0;
3140         if (nla[NFTA_SET_FLAGS] != NULL) {
3141                 flags = ntohl(nla_get_be32(nla[NFTA_SET_FLAGS]));
3142                 if (flags & ~(NFT_SET_ANONYMOUS | NFT_SET_CONSTANT |
3143                               NFT_SET_INTERVAL | NFT_SET_TIMEOUT |
3144                               NFT_SET_MAP | NFT_SET_EVAL |
3145                               NFT_SET_OBJECT))
3146                         return -EOPNOTSUPP;
3147                 /* Only one of these operations is supported */
3148                 if ((flags & (NFT_SET_MAP | NFT_SET_OBJECT)) ==
3149                              (NFT_SET_MAP | NFT_SET_OBJECT))
3150                         return -EOPNOTSUPP;
3151                 if ((flags & (NFT_SET_EVAL | NFT_SET_OBJECT)) ==
3152                              (NFT_SET_EVAL | NFT_SET_OBJECT))
3153                         return -EOPNOTSUPP;
3154         }
3155
3156         dtype = 0;
3157         if (nla[NFTA_SET_DATA_TYPE] != NULL) {
3158                 if (!(flags & NFT_SET_MAP))
3159                         return -EINVAL;
3160
3161                 dtype = ntohl(nla_get_be32(nla[NFTA_SET_DATA_TYPE]));
3162                 if ((dtype & NFT_DATA_RESERVED_MASK) == NFT_DATA_RESERVED_MASK &&
3163                     dtype != NFT_DATA_VERDICT)
3164                         return -EINVAL;
3165
3166                 if (dtype != NFT_DATA_VERDICT) {
3167                         if (nla[NFTA_SET_DATA_LEN] == NULL)
3168                                 return -EINVAL;
3169                         desc.dlen = ntohl(nla_get_be32(nla[NFTA_SET_DATA_LEN]));
3170                         if (desc.dlen == 0 || desc.dlen > NFT_DATA_VALUE_MAXLEN)
3171                                 return -EINVAL;
3172                 } else
3173                         desc.dlen = sizeof(struct nft_verdict);
3174         } else if (flags & NFT_SET_MAP)
3175                 return -EINVAL;
3176
3177         if (nla[NFTA_SET_OBJ_TYPE] != NULL) {
3178                 if (!(flags & NFT_SET_OBJECT))
3179                         return -EINVAL;
3180
3181                 objtype = ntohl(nla_get_be32(nla[NFTA_SET_OBJ_TYPE]));
3182                 if (objtype == NFT_OBJECT_UNSPEC ||
3183                     objtype > NFT_OBJECT_MAX)
3184                         return -EOPNOTSUPP;
3185         } else if (flags & NFT_SET_OBJECT)
3186                 return -EINVAL;
3187         else
3188                 objtype = NFT_OBJECT_UNSPEC;
3189
3190         timeout = 0;
3191         if (nla[NFTA_SET_TIMEOUT] != NULL) {
3192                 if (!(flags & NFT_SET_TIMEOUT))
3193                         return -EINVAL;
3194                 timeout = msecs_to_jiffies(be64_to_cpu(nla_get_be64(
3195                                                 nla[NFTA_SET_TIMEOUT])));
3196         }
3197         gc_int = 0;
3198         if (nla[NFTA_SET_GC_INTERVAL] != NULL) {
3199                 if (!(flags & NFT_SET_TIMEOUT))
3200                         return -EINVAL;
3201                 gc_int = ntohl(nla_get_be32(nla[NFTA_SET_GC_INTERVAL]));
3202         }
3203
3204         policy = NFT_SET_POL_PERFORMANCE;
3205         if (nla[NFTA_SET_POLICY] != NULL)
3206                 policy = ntohl(nla_get_be32(nla[NFTA_SET_POLICY]));
3207
3208         if (nla[NFTA_SET_DESC] != NULL) {
3209                 err = nf_tables_set_desc_parse(&ctx, &desc, nla[NFTA_SET_DESC]);
3210                 if (err < 0)
3211                         return err;
3212         }
3213
3214         create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false;
3215
3216         afi = nf_tables_afinfo_lookup(net, nfmsg->nfgen_family, create);
3217         if (IS_ERR(afi))
3218                 return PTR_ERR(afi);
3219
3220         table = nf_tables_table_lookup(afi, nla[NFTA_SET_TABLE], genmask);
3221         if (IS_ERR(table))
3222                 return PTR_ERR(table);
3223
3224         nft_ctx_init(&ctx, net, skb, nlh, afi, table, NULL, nla);
3225
3226         set = nf_tables_set_lookup(table, nla[NFTA_SET_NAME], genmask);
3227         if (IS_ERR(set)) {
3228                 if (PTR_ERR(set) != -ENOENT)
3229                         return PTR_ERR(set);
3230         } else {
3231                 if (nlh->nlmsg_flags & NLM_F_EXCL)
3232                         return -EEXIST;
3233                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
3234                         return -EOPNOTSUPP;
3235                 return 0;
3236         }
3237
3238         if (!(nlh->nlmsg_flags & NLM_F_CREATE))
3239                 return -ENOENT;
3240
3241         ops = nft_select_set_ops(&ctx, nla, &desc, policy);
3242         if (IS_ERR(ops))
3243                 return PTR_ERR(ops);
3244
3245         udlen = 0;
3246         if (nla[NFTA_SET_USERDATA])
3247                 udlen = nla_len(nla[NFTA_SET_USERDATA]);
3248
3249         size = 0;
3250         if (ops->privsize != NULL)
3251                 size = ops->privsize(nla, &desc);
3252
3253         set = kvzalloc(sizeof(*set) + size + udlen, GFP_KERNEL);
3254         if (!set) {
3255                 err = -ENOMEM;
3256                 goto err1;
3257         }
3258
3259         name = nla_strdup(nla[NFTA_SET_NAME], GFP_KERNEL);
3260         if (!name) {
3261                 err = -ENOMEM;
3262                 goto err2;
3263         }
3264
3265         err = nf_tables_set_alloc_name(&ctx, set, name);
3266         kfree(name);
3267         if (err < 0)
3268                 goto err2;
3269
3270         udata = NULL;
3271         if (udlen) {
3272                 udata = set->data + size;
3273                 nla_memcpy(udata, nla[NFTA_SET_USERDATA], udlen);
3274         }
3275
3276         INIT_LIST_HEAD(&set->bindings);
3277         set->table = table;
3278         set->ops   = ops;
3279         set->ktype = ktype;
3280         set->klen  = desc.klen;
3281         set->dtype = dtype;
3282         set->objtype = objtype;
3283         set->dlen  = desc.dlen;
3284         set->flags = flags;
3285         set->size  = desc.size;
3286         set->policy = policy;
3287         set->udlen  = udlen;
3288         set->udata  = udata;
3289         set->timeout = timeout;
3290         set->gc_int = gc_int;
3291
3292         err = ops->init(set, &desc, nla);
3293         if (err < 0)
3294                 goto err3;
3295
3296         err = nft_trans_set_add(&ctx, NFT_MSG_NEWSET, set);
3297         if (err < 0)
3298                 goto err4;
3299
3300         list_add_tail_rcu(&set->list, &table->sets);
3301         table->use++;
3302         return 0;
3303
3304 err4:
3305         ops->destroy(set);
3306 err3:
3307         kfree(set->name);
3308 err2:
3309         kvfree(set);
3310 err1:
3311         module_put(ops->type->owner);
3312         return err;
3313 }
3314
3315 static void nft_set_destroy(struct nft_set *set)
3316 {
3317         if (WARN_ON(set->use > 0))
3318                 return;
3319
3320         set->ops->destroy(set);
3321         module_put(set->ops->type->owner);
3322         kfree(set->name);
3323         kvfree(set);
3324 }
3325
3326 static int nf_tables_delset(struct net *net, struct sock *nlsk,
3327                             struct sk_buff *skb, const struct nlmsghdr *nlh,
3328                             const struct nlattr * const nla[],
3329                             struct netlink_ext_ack *extack)
3330 {
3331         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
3332         u8 genmask = nft_genmask_next(net);
3333         struct nft_set *set;
3334         struct nft_ctx ctx;
3335         int err;
3336
3337         if (nfmsg->nfgen_family == NFPROTO_UNSPEC)
3338                 return -EAFNOSUPPORT;
3339         if (nla[NFTA_SET_TABLE] == NULL)
3340                 return -EINVAL;
3341
3342         err = nft_ctx_init_from_setattr(&ctx, net, skb, nlh, nla, genmask);
3343         if (err < 0)
3344                 return err;
3345
3346         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME], genmask);
3347         if (IS_ERR(set))
3348                 return PTR_ERR(set);
3349
3350         if (set->use ||
3351             (nlh->nlmsg_flags & NLM_F_NONREC && atomic_read(&set->nelems) > 0))
3352                 return -EBUSY;
3353
3354         return nft_delset(&ctx, set);
3355 }
3356
3357 static int nft_validate_register_store(const struct nft_ctx *ctx,
3358                                        enum nft_registers reg,
3359                                        const struct nft_data *data,
3360                                        enum nft_data_types type,
3361                                        unsigned int len);
3362
3363 static int nf_tables_bind_check_setelem(const struct nft_ctx *ctx,
3364                                         struct nft_set *set,
3365                                         const struct nft_set_iter *iter,
3366                                         struct nft_set_elem *elem)
3367 {
3368         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
3369         enum nft_registers dreg;
3370
3371         dreg = nft_type_to_reg(set->dtype);
3372         return nft_validate_register_store(ctx, dreg, nft_set_ext_data(ext),
3373                                            set->dtype == NFT_DATA_VERDICT ?
3374                                            NFT_DATA_VERDICT : NFT_DATA_VALUE,
3375                                            set->dlen);
3376 }
3377
3378 int nf_tables_bind_set(const struct nft_ctx *ctx, struct nft_set *set,
3379                        struct nft_set_binding *binding)
3380 {
3381         struct nft_set_binding *i;
3382         struct nft_set_iter iter;
3383
3384         if (set->use == UINT_MAX)
3385                 return -EOVERFLOW;
3386
3387         if (!list_empty(&set->bindings) && set->flags & NFT_SET_ANONYMOUS)
3388                 return -EBUSY;
3389
3390         if (binding->flags & NFT_SET_MAP) {
3391                 /* If the set is already bound to the same chain all
3392                  * jumps are already validated for that chain.
3393                  */
3394                 list_for_each_entry(i, &set->bindings, list) {
3395                         if (i->flags & NFT_SET_MAP &&
3396                             i->chain == binding->chain)
3397                                 goto bind;
3398                 }
3399
3400                 iter.genmask    = nft_genmask_next(ctx->net);
3401                 iter.skip       = 0;
3402                 iter.count      = 0;
3403                 iter.err        = 0;
3404                 iter.fn         = nf_tables_bind_check_setelem;
3405
3406                 set->ops->walk(ctx, set, &iter);
3407                 if (iter.err < 0)
3408                         return iter.err;
3409         }
3410 bind:
3411         binding->chain = ctx->chain;
3412         list_add_tail_rcu(&binding->list, &set->bindings);
3413         nft_set_trans_bind(ctx, set);
3414         set->use++;
3415
3416         return 0;
3417 }
3418 EXPORT_SYMBOL_GPL(nf_tables_bind_set);
3419
3420 void nf_tables_unbind_set(const struct nft_ctx *ctx, struct nft_set *set,
3421                           struct nft_set_binding *binding, bool event)
3422 {
3423         list_del_rcu(&binding->list);
3424
3425         if (list_empty(&set->bindings) && set->flags & NFT_SET_ANONYMOUS) {
3426                 list_del_rcu(&set->list);
3427                 if (event)
3428                         nf_tables_set_notify(ctx, set, NFT_MSG_DELSET,
3429                                              GFP_KERNEL);
3430         }
3431 }
3432 EXPORT_SYMBOL_GPL(nf_tables_unbind_set);
3433
3434 void nf_tables_activate_set(const struct nft_ctx *ctx, struct nft_set *set)
3435 {
3436         if (set->flags & NFT_SET_ANONYMOUS)
3437                 nft_clear(ctx->net, set);
3438
3439         set->use++;
3440 }
3441 EXPORT_SYMBOL_GPL(nf_tables_activate_set);
3442
3443 void nf_tables_deactivate_set(const struct nft_ctx *ctx, struct nft_set *set,
3444                               struct nft_set_binding *binding,
3445                               enum nft_trans_phase phase)
3446 {
3447         switch (phase) {
3448         case NFT_TRANS_PREPARE:
3449                 if (set->flags & NFT_SET_ANONYMOUS)
3450                         nft_deactivate_next(ctx->net, set);
3451
3452                 set->use--;
3453                 return;
3454         case NFT_TRANS_ABORT:
3455         case NFT_TRANS_RELEASE:
3456                 set->use--;
3457                 /* fall through */
3458         default:
3459                 nf_tables_unbind_set(ctx, set, binding,
3460                                      phase == NFT_TRANS_COMMIT);
3461         }
3462 }
3463 EXPORT_SYMBOL_GPL(nf_tables_deactivate_set);
3464
3465 void nf_tables_destroy_set(const struct nft_ctx *ctx, struct nft_set *set)
3466 {
3467         if (list_empty(&set->bindings) && set->flags & NFT_SET_ANONYMOUS)
3468                 nft_set_destroy(set);
3469 }
3470 EXPORT_SYMBOL_GPL(nf_tables_destroy_set);
3471
3472 const struct nft_set_ext_type nft_set_ext_types[] = {
3473         [NFT_SET_EXT_KEY]               = {
3474                 .align  = __alignof__(u32),
3475         },
3476         [NFT_SET_EXT_DATA]              = {
3477                 .align  = __alignof__(u32),
3478         },
3479         [NFT_SET_EXT_EXPR]              = {
3480                 .align  = __alignof__(struct nft_expr),
3481         },
3482         [NFT_SET_EXT_OBJREF]            = {
3483                 .len    = sizeof(struct nft_object *),
3484                 .align  = __alignof__(struct nft_object *),
3485         },
3486         [NFT_SET_EXT_FLAGS]             = {
3487                 .len    = sizeof(u8),
3488                 .align  = __alignof__(u8),
3489         },
3490         [NFT_SET_EXT_TIMEOUT]           = {
3491                 .len    = sizeof(u64),
3492                 .align  = __alignof__(u64),
3493         },
3494         [NFT_SET_EXT_EXPIRATION]        = {
3495                 .len    = sizeof(unsigned long),
3496                 .align  = __alignof__(unsigned long),
3497         },
3498         [NFT_SET_EXT_USERDATA]          = {
3499                 .len    = sizeof(struct nft_userdata),
3500                 .align  = __alignof__(struct nft_userdata),
3501         },
3502 };
3503 EXPORT_SYMBOL_GPL(nft_set_ext_types);
3504
3505 /*
3506  * Set elements
3507  */
3508
3509 static const struct nla_policy nft_set_elem_policy[NFTA_SET_ELEM_MAX + 1] = {
3510         [NFTA_SET_ELEM_KEY]             = { .type = NLA_NESTED },
3511         [NFTA_SET_ELEM_DATA]            = { .type = NLA_NESTED },
3512         [NFTA_SET_ELEM_FLAGS]           = { .type = NLA_U32 },
3513         [NFTA_SET_ELEM_TIMEOUT]         = { .type = NLA_U64 },
3514         [NFTA_SET_ELEM_USERDATA]        = { .type = NLA_BINARY,
3515                                             .len = NFT_USERDATA_MAXLEN },
3516         [NFTA_SET_ELEM_EXPR]            = { .type = NLA_NESTED },
3517         [NFTA_SET_ELEM_OBJREF]          = { .type = NLA_STRING },
3518 };
3519
3520 static const struct nla_policy nft_set_elem_list_policy[NFTA_SET_ELEM_LIST_MAX + 1] = {
3521         [NFTA_SET_ELEM_LIST_TABLE]      = { .type = NLA_STRING,
3522                                             .len = NFT_TABLE_MAXNAMELEN - 1 },
3523         [NFTA_SET_ELEM_LIST_SET]        = { .type = NLA_STRING,
3524                                             .len = NFT_SET_MAXNAMELEN - 1 },
3525         [NFTA_SET_ELEM_LIST_ELEMENTS]   = { .type = NLA_NESTED },
3526         [NFTA_SET_ELEM_LIST_SET_ID]     = { .type = NLA_U32 },
3527 };
3528
3529 static int nft_ctx_init_from_elemattr(struct nft_ctx *ctx, struct net *net,
3530                                       const struct sk_buff *skb,
3531                                       const struct nlmsghdr *nlh,
3532                                       const struct nlattr * const nla[],
3533                                       u8 genmask)
3534 {
3535         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
3536         struct nft_af_info *afi;
3537         struct nft_table *table;
3538
3539         afi = nf_tables_afinfo_lookup(net, nfmsg->nfgen_family, false);
3540         if (IS_ERR(afi))
3541                 return PTR_ERR(afi);
3542
3543         table = nf_tables_table_lookup(afi, nla[NFTA_SET_ELEM_LIST_TABLE],
3544                                        genmask);
3545         if (IS_ERR(table))
3546                 return PTR_ERR(table);
3547
3548         nft_ctx_init(ctx, net, skb, nlh, afi, table, NULL, nla);
3549         return 0;
3550 }
3551
3552 static int nf_tables_fill_setelem(struct sk_buff *skb,
3553                                   const struct nft_set *set,
3554                                   const struct nft_set_elem *elem)
3555 {
3556         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
3557         unsigned char *b = skb_tail_pointer(skb);
3558         struct nlattr *nest;
3559
3560         nest = nla_nest_start(skb, NFTA_LIST_ELEM);
3561         if (nest == NULL)
3562                 goto nla_put_failure;
3563
3564         if (nft_data_dump(skb, NFTA_SET_ELEM_KEY, nft_set_ext_key(ext),
3565                           NFT_DATA_VALUE, set->klen) < 0)
3566                 goto nla_put_failure;
3567
3568         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA) &&
3569             nft_data_dump(skb, NFTA_SET_ELEM_DATA, nft_set_ext_data(ext),
3570                           set->dtype == NFT_DATA_VERDICT ? NFT_DATA_VERDICT : NFT_DATA_VALUE,
3571                           set->dlen) < 0)
3572                 goto nla_put_failure;
3573
3574         if (nft_set_ext_exists(ext, NFT_SET_EXT_EXPR) &&
3575             nft_expr_dump(skb, NFTA_SET_ELEM_EXPR, nft_set_ext_expr(ext)) < 0)
3576                 goto nla_put_failure;
3577
3578         if (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF) &&
3579             nla_put_string(skb, NFTA_SET_ELEM_OBJREF,
3580                            (*nft_set_ext_obj(ext))->name) < 0)
3581                 goto nla_put_failure;
3582
3583         if (nft_set_ext_exists(ext, NFT_SET_EXT_FLAGS) &&
3584             nla_put_be32(skb, NFTA_SET_ELEM_FLAGS,
3585                          htonl(*nft_set_ext_flags(ext))))
3586                 goto nla_put_failure;
3587
3588         if (nft_set_ext_exists(ext, NFT_SET_EXT_TIMEOUT) &&
3589             nla_put_be64(skb, NFTA_SET_ELEM_TIMEOUT,
3590                          cpu_to_be64(jiffies_to_msecs(
3591                                                 *nft_set_ext_timeout(ext))),
3592                          NFTA_SET_ELEM_PAD))
3593                 goto nla_put_failure;
3594
3595         if (nft_set_ext_exists(ext, NFT_SET_EXT_EXPIRATION)) {
3596                 unsigned long expires, now = jiffies;
3597
3598                 expires = *nft_set_ext_expiration(ext);
3599                 if (time_before(now, expires))
3600                         expires -= now;
3601                 else
3602                         expires = 0;
3603
3604                 if (nla_put_be64(skb, NFTA_SET_ELEM_EXPIRATION,
3605                                  cpu_to_be64(jiffies_to_msecs(expires)),
3606                                  NFTA_SET_ELEM_PAD))
3607                         goto nla_put_failure;
3608         }
3609
3610         if (nft_set_ext_exists(ext, NFT_SET_EXT_USERDATA)) {
3611                 struct nft_userdata *udata;
3612
3613                 udata = nft_set_ext_userdata(ext);
3614                 if (nla_put(skb, NFTA_SET_ELEM_USERDATA,
3615                             udata->len + 1, udata->data))
3616                         goto nla_put_failure;
3617         }
3618
3619         nla_nest_end(skb, nest);
3620         return 0;
3621
3622 nla_put_failure:
3623         nlmsg_trim(skb, b);
3624         return -EMSGSIZE;
3625 }
3626
3627 struct nft_set_dump_args {
3628         const struct netlink_callback   *cb;
3629         struct nft_set_iter             iter;
3630         struct sk_buff                  *skb;
3631 };
3632
3633 static int nf_tables_dump_setelem(const struct nft_ctx *ctx,
3634                                   struct nft_set *set,
3635                                   const struct nft_set_iter *iter,
3636                                   struct nft_set_elem *elem)
3637 {
3638         struct nft_set_dump_args *args;
3639
3640         args = container_of(iter, struct nft_set_dump_args, iter);
3641         return nf_tables_fill_setelem(args->skb, set, elem);
3642 }
3643
3644 struct nft_set_dump_ctx {
3645         const struct nft_set    *set;
3646         struct nft_ctx          ctx;
3647 };
3648
3649 static int nf_tables_dump_set(struct sk_buff *skb, struct netlink_callback *cb)
3650 {
3651         struct nft_set_dump_ctx *dump_ctx = cb->data;
3652         struct net *net = sock_net(skb->sk);
3653         struct nft_af_info *afi;
3654         struct nft_table *table;
3655         struct nft_set *set;
3656         struct nft_set_dump_args args;
3657         bool set_found = false;
3658         struct nfgenmsg *nfmsg;
3659         struct nlmsghdr *nlh;
3660         struct nlattr *nest;
3661         u32 portid, seq;
3662         int event;
3663
3664         rcu_read_lock();
3665         list_for_each_entry_rcu(afi, &net->nft.af_info, list) {
3666                 if (afi != dump_ctx->ctx.afi)
3667                         continue;
3668
3669                 list_for_each_entry_rcu(table, &afi->tables, list) {
3670                         if (table != dump_ctx->ctx.table)
3671                                 continue;
3672
3673                         list_for_each_entry_rcu(set, &table->sets, list) {
3674                                 if (set == dump_ctx->set) {
3675                                         set_found = true;
3676                                         break;
3677                                 }
3678                         }
3679                         break;
3680                 }
3681                 break;
3682         }
3683
3684         if (!set_found) {
3685                 rcu_read_unlock();
3686                 return -ENOENT;
3687         }
3688
3689         event  = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWSETELEM);
3690         portid = NETLINK_CB(cb->skb).portid;
3691         seq    = cb->nlh->nlmsg_seq;
3692
3693         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg),
3694                         NLM_F_MULTI);
3695         if (nlh == NULL)
3696                 goto nla_put_failure;
3697
3698         nfmsg = nlmsg_data(nlh);
3699         nfmsg->nfgen_family = afi->family;
3700         nfmsg->version      = NFNETLINK_V0;
3701         nfmsg->res_id       = htons(net->nft.base_seq & 0xffff);
3702
3703         if (nla_put_string(skb, NFTA_SET_ELEM_LIST_TABLE, table->name))
3704                 goto nla_put_failure;
3705         if (nla_put_string(skb, NFTA_SET_ELEM_LIST_SET, set->name))
3706                 goto nla_put_failure;
3707
3708         nest = nla_nest_start(skb, NFTA_SET_ELEM_LIST_ELEMENTS);
3709         if (nest == NULL)
3710                 goto nla_put_failure;
3711
3712         args.cb                 = cb;
3713         args.skb                = skb;
3714         args.iter.genmask       = nft_genmask_cur(net);
3715         args.iter.skip          = cb->args[0];
3716         args.iter.count         = 0;
3717         args.iter.err           = 0;
3718         args.iter.fn            = nf_tables_dump_setelem;
3719         set->ops->walk(&dump_ctx->ctx, set, &args.iter);
3720         rcu_read_unlock();
3721
3722         nla_nest_end(skb, nest);
3723         nlmsg_end(skb, nlh);
3724
3725         if (args.iter.err && args.iter.err != -EMSGSIZE)
3726                 return args.iter.err;
3727         if (args.iter.count == cb->args[0])
3728                 return 0;
3729
3730         cb->args[0] = args.iter.count;
3731         return skb->len;
3732
3733 nla_put_failure:
3734         rcu_read_unlock();
3735         return -ENOSPC;
3736 }
3737
3738 static int nf_tables_dump_set_done(struct netlink_callback *cb)
3739 {
3740         kfree(cb->data);
3741         return 0;
3742 }
3743
3744 static int nft_setelem_parse_key(struct nft_ctx *ctx, struct nft_set *set,
3745                                  struct nft_data *key, struct nlattr *attr)
3746 {
3747         struct nft_data_desc desc;
3748         int err;
3749
3750         err = nft_data_init(ctx, key, NFT_DATA_VALUE_MAXLEN, &desc, attr);
3751         if (err < 0)
3752                 return err;
3753
3754         if (desc.type != NFT_DATA_VALUE || desc.len != set->klen) {
3755                 nft_data_release(key, desc.type);
3756                 return -EINVAL;
3757         }
3758
3759         return 0;
3760 }
3761
3762 static int nf_tables_getsetelem(struct net *net, struct sock *nlsk,
3763                                 struct sk_buff *skb, const struct nlmsghdr *nlh,
3764                                 const struct nlattr * const nla[],
3765                                 struct netlink_ext_ack *extack)
3766 {
3767         u8 genmask = nft_genmask_cur(net);
3768         const struct nft_set *set;
3769         struct nft_ctx ctx;
3770         int err;
3771
3772         err = nft_ctx_init_from_elemattr(&ctx, net, skb, nlh, nla, genmask);
3773         if (err < 0)
3774                 return err;
3775
3776         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET],
3777                                    genmask);
3778         if (IS_ERR(set))
3779                 return PTR_ERR(set);
3780
3781         if (nlh->nlmsg_flags & NLM_F_DUMP) {
3782                 struct netlink_dump_control c = {
3783                         .dump = nf_tables_dump_set,
3784                         .done = nf_tables_dump_set_done,
3785                 };
3786                 struct nft_set_dump_ctx *dump_ctx;
3787
3788                 dump_ctx = kmalloc(sizeof(*dump_ctx), GFP_KERNEL);
3789                 if (!dump_ctx)
3790                         return -ENOMEM;
3791
3792                 dump_ctx->set = set;
3793                 dump_ctx->ctx = ctx;
3794
3795                 c.data = dump_ctx;
3796                 return netlink_dump_start(nlsk, skb, nlh, &c);
3797         }
3798         return -EOPNOTSUPP;
3799 }
3800
3801 static int nf_tables_fill_setelem_info(struct sk_buff *skb,
3802                                        const struct nft_ctx *ctx, u32 seq,
3803                                        u32 portid, int event, u16 flags,
3804                                        const struct nft_set *set,
3805                                        const struct nft_set_elem *elem)
3806 {
3807         struct nfgenmsg *nfmsg;
3808         struct nlmsghdr *nlh;
3809         struct nlattr *nest;
3810         int err;
3811
3812         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
3813         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg),
3814                         flags);
3815         if (nlh == NULL)
3816                 goto nla_put_failure;
3817
3818         nfmsg = nlmsg_data(nlh);
3819         nfmsg->nfgen_family     = ctx->afi->family;
3820         nfmsg->version          = NFNETLINK_V0;
3821         nfmsg->res_id           = htons(ctx->net->nft.base_seq & 0xffff);
3822
3823         if (nla_put_string(skb, NFTA_SET_TABLE, ctx->table->name))
3824                 goto nla_put_failure;
3825         if (nla_put_string(skb, NFTA_SET_NAME, set->name))
3826                 goto nla_put_failure;
3827
3828         nest = nla_nest_start(skb, NFTA_SET_ELEM_LIST_ELEMENTS);
3829         if (nest == NULL)
3830                 goto nla_put_failure;
3831
3832         err = nf_tables_fill_setelem(skb, set, elem);
3833         if (err < 0)
3834                 goto nla_put_failure;
3835
3836         nla_nest_end(skb, nest);
3837
3838         nlmsg_end(skb, nlh);
3839         return 0;
3840
3841 nla_put_failure:
3842         nlmsg_trim(skb, nlh);
3843         return -1;
3844 }
3845
3846 static void nf_tables_setelem_notify(const struct nft_ctx *ctx,
3847                                      const struct nft_set *set,
3848                                      const struct nft_set_elem *elem,
3849                                      int event, u16 flags)
3850 {
3851         struct net *net = ctx->net;
3852         u32 portid = ctx->portid;
3853         struct sk_buff *skb;
3854         int err;
3855
3856         if (!ctx->report && !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
3857                 return;
3858
3859         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
3860         if (skb == NULL)
3861                 goto err;
3862
3863         err = nf_tables_fill_setelem_info(skb, ctx, 0, portid, event, flags,
3864                                           set, elem);
3865         if (err < 0) {
3866                 kfree_skb(skb);
3867                 goto err;
3868         }
3869
3870         nfnetlink_send(skb, net, portid, NFNLGRP_NFTABLES, ctx->report,
3871                        GFP_KERNEL);
3872         return;
3873 err:
3874         nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
3875 }
3876
3877 static struct nft_trans *nft_trans_elem_alloc(struct nft_ctx *ctx,
3878                                               int msg_type,
3879                                               struct nft_set *set)
3880 {
3881         struct nft_trans *trans;
3882
3883         trans = nft_trans_alloc(ctx, msg_type, sizeof(struct nft_trans_elem));
3884         if (trans == NULL)
3885                 return NULL;
3886
3887         nft_trans_elem_set(trans) = set;
3888         return trans;
3889 }
3890
3891 void *nft_set_elem_init(const struct nft_set *set,
3892                         const struct nft_set_ext_tmpl *tmpl,
3893                         const u32 *key, const u32 *data,
3894                         u64 timeout, gfp_t gfp)
3895 {
3896         struct nft_set_ext *ext;
3897         void *elem;
3898
3899         elem = kzalloc(set->ops->elemsize + tmpl->len, gfp);
3900         if (elem == NULL)
3901                 return NULL;
3902
3903         ext = nft_set_elem_ext(set, elem);
3904         nft_set_ext_init(ext, tmpl);
3905
3906         memcpy(nft_set_ext_key(ext), key, set->klen);
3907         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA))
3908                 memcpy(nft_set_ext_data(ext), data, set->dlen);
3909         if (nft_set_ext_exists(ext, NFT_SET_EXT_EXPIRATION))
3910                 *nft_set_ext_expiration(ext) =
3911                         jiffies + timeout;
3912         if (nft_set_ext_exists(ext, NFT_SET_EXT_TIMEOUT))
3913                 *nft_set_ext_timeout(ext) = timeout;
3914
3915         return elem;
3916 }
3917
3918 void nft_set_elem_destroy(const struct nft_set *set, void *elem,
3919                           bool destroy_expr)
3920 {
3921         struct nft_set_ext *ext = nft_set_elem_ext(set, elem);
3922
3923         nft_data_release(nft_set_ext_key(ext), NFT_DATA_VALUE);
3924         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA))
3925                 nft_data_release(nft_set_ext_data(ext), set->dtype);
3926         if (destroy_expr && nft_set_ext_exists(ext, NFT_SET_EXT_EXPR))
3927                 nf_tables_expr_destroy(NULL, nft_set_ext_expr(ext));
3928         if (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF))
3929                 (*nft_set_ext_obj(ext))->use--;
3930         kfree(elem);
3931 }
3932 EXPORT_SYMBOL_GPL(nft_set_elem_destroy);
3933
3934 /* Only called from commit path, nft_set_elem_deactivate() already deals with
3935  * the refcounting from the preparation phase.
3936  */
3937 static void nf_tables_set_elem_destroy(const struct nft_set *set, void *elem)
3938 {
3939         struct nft_set_ext *ext = nft_set_elem_ext(set, elem);
3940
3941         if (nft_set_ext_exists(ext, NFT_SET_EXT_EXPR))
3942                 nf_tables_expr_destroy(NULL, nft_set_ext_expr(ext));
3943         kfree(elem);
3944 }
3945
3946 static int nft_setelem_parse_flags(const struct nft_set *set,
3947                                    const struct nlattr *attr, u32 *flags)
3948 {
3949         if (attr == NULL)
3950                 return 0;
3951
3952         *flags = ntohl(nla_get_be32(attr));
3953         if (*flags & ~NFT_SET_ELEM_INTERVAL_END)
3954                 return -EINVAL;
3955         if (!(set->flags & NFT_SET_INTERVAL) &&
3956             *flags & NFT_SET_ELEM_INTERVAL_END)
3957                 return -EINVAL;
3958
3959         return 0;
3960 }
3961
3962 static int nft_setelem_parse_data(struct nft_ctx *ctx, struct nft_set *set,
3963                                   struct nft_data_desc *desc,
3964                                   struct nft_data *data,
3965                                   struct nlattr *attr)
3966 {
3967         u32 dtype;
3968         int err;
3969
3970         err = nft_data_init(ctx, data, NFT_DATA_VALUE_MAXLEN, desc, attr);
3971         if (err < 0)
3972                 return err;
3973
3974         if (set->dtype == NFT_DATA_VERDICT)
3975                 dtype = NFT_DATA_VERDICT;
3976         else
3977                 dtype = NFT_DATA_VALUE;
3978
3979         if (dtype != desc->type ||
3980             set->dlen != desc->len) {
3981                 nft_data_release(data, desc->type);
3982                 return -EINVAL;
3983         }
3984
3985         return 0;
3986 }
3987
3988 static int nft_add_set_elem(struct nft_ctx *ctx, struct nft_set *set,
3989                             const struct nlattr *attr, u32 nlmsg_flags)
3990 {
3991         struct nlattr *nla[NFTA_SET_ELEM_MAX + 1];
3992         u8 genmask = nft_genmask_next(ctx->net);
3993         struct nft_set_ext_tmpl tmpl;
3994         struct nft_set_ext *ext, *ext2;
3995         struct nft_set_elem elem;
3996         struct nft_set_binding *binding;
3997         struct nft_object *obj = NULL;
3998         struct nft_userdata *udata;
3999         struct nft_data_desc desc;
4000         enum nft_registers dreg;
4001         struct nft_trans *trans;
4002         u32 flags = 0;
4003         u64 timeout;
4004         u8 ulen;
4005         int err;
4006
4007         err = nla_parse_nested(nla, NFTA_SET_ELEM_MAX, attr,
4008                                nft_set_elem_policy, NULL);
4009         if (err < 0)
4010                 return err;
4011
4012         if (nla[NFTA_SET_ELEM_KEY] == NULL)
4013                 return -EINVAL;
4014
4015         nft_set_ext_prepare(&tmpl);
4016
4017         err = nft_setelem_parse_flags(set, nla[NFTA_SET_ELEM_FLAGS], &flags);
4018         if (err < 0)
4019                 return err;
4020         if (flags != 0)
4021                 nft_set_ext_add(&tmpl, NFT_SET_EXT_FLAGS);
4022
4023         if (set->flags & NFT_SET_MAP) {
4024                 if (nla[NFTA_SET_ELEM_DATA] == NULL &&
4025                     !(flags & NFT_SET_ELEM_INTERVAL_END))
4026                         return -EINVAL;
4027         } else {
4028                 if (nla[NFTA_SET_ELEM_DATA] != NULL)
4029                         return -EINVAL;
4030         }
4031
4032         if ((flags & NFT_SET_ELEM_INTERVAL_END) &&
4033              (nla[NFTA_SET_ELEM_DATA] ||
4034               nla[NFTA_SET_ELEM_OBJREF] ||
4035               nla[NFTA_SET_ELEM_TIMEOUT] ||
4036               nla[NFTA_SET_ELEM_EXPIRATION] ||
4037               nla[NFTA_SET_ELEM_USERDATA] ||
4038               nla[NFTA_SET_ELEM_EXPR]))
4039                 return -EINVAL;
4040
4041         timeout = 0;
4042         if (nla[NFTA_SET_ELEM_TIMEOUT] != NULL) {
4043                 if (!(set->flags & NFT_SET_TIMEOUT))
4044                         return -EINVAL;
4045                 timeout = msecs_to_jiffies(be64_to_cpu(nla_get_be64(
4046                                         nla[NFTA_SET_ELEM_TIMEOUT])));
4047         } else if (set->flags & NFT_SET_TIMEOUT) {
4048                 timeout = set->timeout;
4049         }
4050
4051         err = nft_setelem_parse_key(ctx, set, &elem.key.val,
4052                                     nla[NFTA_SET_ELEM_KEY]);
4053         if (err < 0)
4054                 goto err1;
4055
4056         nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY, set->klen);
4057         if (timeout > 0) {
4058                 nft_set_ext_add(&tmpl, NFT_SET_EXT_EXPIRATION);
4059                 if (timeout != set->timeout)
4060                         nft_set_ext_add(&tmpl, NFT_SET_EXT_TIMEOUT);
4061         }
4062
4063         if (nla[NFTA_SET_ELEM_OBJREF] != NULL) {
4064                 if (!(set->flags & NFT_SET_OBJECT)) {
4065                         err = -EINVAL;
4066                         goto err2;
4067                 }
4068                 obj = nf_tables_obj_lookup(ctx->table, nla[NFTA_SET_ELEM_OBJREF],
4069                                            set->objtype, genmask);
4070                 if (IS_ERR(obj)) {
4071                         err = PTR_ERR(obj);
4072                         goto err2;
4073                 }
4074                 nft_set_ext_add(&tmpl, NFT_SET_EXT_OBJREF);
4075         }
4076
4077         if (nla[NFTA_SET_ELEM_DATA] != NULL) {
4078                 err = nft_setelem_parse_data(ctx, set, &desc, &elem.data.val,
4079                                              nla[NFTA_SET_ELEM_DATA]);
4080                 if (err < 0)
4081                         goto err2;
4082
4083                 dreg = nft_type_to_reg(set->dtype);
4084                 list_for_each_entry(binding, &set->bindings, list) {
4085                         struct nft_ctx bind_ctx = {
4086                                 .net    = ctx->net,
4087                                 .afi    = ctx->afi,
4088                                 .table  = ctx->table,
4089                                 .chain  = (struct nft_chain *)binding->chain,
4090                         };
4091
4092                         if (!(binding->flags & NFT_SET_MAP))
4093                                 continue;
4094
4095                         err = nft_validate_register_store(&bind_ctx, dreg,
4096                                                           &elem.data.val,
4097                                                           desc.type, desc.len);
4098                         if (err < 0)
4099                                 goto err3;
4100                 }
4101
4102                 nft_set_ext_add_length(&tmpl, NFT_SET_EXT_DATA, desc.len);
4103         }
4104
4105         /* The full maximum length of userdata can exceed the maximum
4106          * offset value (U8_MAX) for following extensions, therefor it
4107          * must be the last extension added.
4108          */
4109         ulen = 0;
4110         if (nla[NFTA_SET_ELEM_USERDATA] != NULL) {
4111                 ulen = nla_len(nla[NFTA_SET_ELEM_USERDATA]);
4112                 if (ulen > 0)
4113                         nft_set_ext_add_length(&tmpl, NFT_SET_EXT_USERDATA,
4114                                                ulen);
4115         }
4116
4117         err = -ENOMEM;
4118         elem.priv = nft_set_elem_init(set, &tmpl, elem.key.val.data,
4119                                       elem.data.val.data,
4120                                       timeout, GFP_KERNEL);
4121         if (elem.priv == NULL)
4122                 goto err3;
4123
4124         ext = nft_set_elem_ext(set, elem.priv);
4125         if (flags)
4126                 *nft_set_ext_flags(ext) = flags;
4127         if (ulen > 0) {
4128                 udata = nft_set_ext_userdata(ext);
4129                 udata->len = ulen - 1;
4130                 nla_memcpy(&udata->data, nla[NFTA_SET_ELEM_USERDATA], ulen);
4131         }
4132         if (obj) {
4133                 *nft_set_ext_obj(ext) = obj;
4134                 obj->use++;
4135         }
4136
4137         trans = nft_trans_elem_alloc(ctx, NFT_MSG_NEWSETELEM, set);
4138         if (trans == NULL)
4139                 goto err4;
4140
4141         ext->genmask = nft_genmask_cur(ctx->net) | NFT_SET_ELEM_BUSY_MASK;
4142         err = set->ops->insert(ctx->net, set, &elem, &ext2);
4143         if (err) {
4144                 if (err == -EEXIST) {
4145                         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA) ^
4146                             nft_set_ext_exists(ext2, NFT_SET_EXT_DATA) ||
4147                             nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF) ^
4148                             nft_set_ext_exists(ext2, NFT_SET_EXT_OBJREF)) {
4149                                 err = -EBUSY;
4150                                 goto err5;
4151                         }
4152                         if ((nft_set_ext_exists(ext, NFT_SET_EXT_DATA) &&
4153                              nft_set_ext_exists(ext2, NFT_SET_EXT_DATA) &&
4154                              memcmp(nft_set_ext_data(ext),
4155                                     nft_set_ext_data(ext2), set->dlen) != 0) ||
4156                             (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF) &&
4157                              nft_set_ext_exists(ext2, NFT_SET_EXT_OBJREF) &&
4158                              *nft_set_ext_obj(ext) != *nft_set_ext_obj(ext2)))
4159                                 err = -EBUSY;
4160                         else if (!(nlmsg_flags & NLM_F_EXCL))
4161                                 err = 0;
4162                 }
4163                 goto err5;
4164         }
4165
4166         if (set->size &&
4167             !atomic_add_unless(&set->nelems, 1, set->size + set->ndeact)) {
4168                 err = -ENFILE;
4169                 goto err6;
4170         }
4171
4172         nft_trans_elem(trans) = elem;
4173         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
4174         return 0;
4175
4176 err6:
4177         set->ops->remove(ctx->net, set, &elem);
4178 err5:
4179         kfree(trans);
4180 err4:
4181         if (obj)
4182                 obj->use--;
4183         kfree(elem.priv);
4184 err3:
4185         if (nla[NFTA_SET_ELEM_DATA] != NULL)
4186                 nft_data_release(&elem.data.val, desc.type);
4187 err2:
4188         nft_data_release(&elem.key.val, NFT_DATA_VALUE);
4189 err1:
4190         return err;
4191 }
4192
4193 static int nf_tables_newsetelem(struct net *net, struct sock *nlsk,
4194                                 struct sk_buff *skb, const struct nlmsghdr *nlh,
4195                                 const struct nlattr * const nla[],
4196                                 struct netlink_ext_ack *extack)
4197 {
4198         u8 genmask = nft_genmask_next(net);
4199         const struct nlattr *attr;
4200         struct nft_set *set;
4201         struct nft_ctx ctx;
4202         int rem, err = 0;
4203
4204         if (nla[NFTA_SET_ELEM_LIST_ELEMENTS] == NULL)
4205                 return -EINVAL;
4206
4207         err = nft_ctx_init_from_elemattr(&ctx, net, skb, nlh, nla, genmask);
4208         if (err < 0)
4209                 return err;
4210
4211         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET],
4212                                    genmask);
4213         if (IS_ERR(set)) {
4214                 if (nla[NFTA_SET_ELEM_LIST_SET_ID]) {
4215                         set = nf_tables_set_lookup_byid(net, ctx.table,
4216                                         nla[NFTA_SET_ELEM_LIST_SET_ID],
4217                                         genmask);
4218                 }
4219                 if (IS_ERR(set))
4220                         return PTR_ERR(set);
4221         }
4222
4223         if (!list_empty(&set->bindings) && set->flags & NFT_SET_CONSTANT)
4224                 return -EBUSY;
4225
4226         nla_for_each_nested(attr, nla[NFTA_SET_ELEM_LIST_ELEMENTS], rem) {
4227                 err = nft_add_set_elem(&ctx, set, attr, nlh->nlmsg_flags);
4228                 if (err < 0)
4229                         break;
4230         }
4231         return err;
4232 }
4233
4234 /**
4235  *      nft_data_hold - hold a nft_data item
4236  *
4237  *      @data: struct nft_data to release
4238  *      @type: type of data
4239  *
4240  *      Hold a nft_data item. NFT_DATA_VALUE types can be silently discarded,
4241  *      NFT_DATA_VERDICT bumps the reference to chains in case of NFT_JUMP and
4242  *      NFT_GOTO verdicts. This function must be called on active data objects
4243  *      from the second phase of the commit protocol.
4244  */
4245 void nft_data_hold(const struct nft_data *data, enum nft_data_types type)
4246 {
4247         if (type == NFT_DATA_VERDICT) {
4248                 switch (data->verdict.code) {
4249                 case NFT_JUMP:
4250                 case NFT_GOTO:
4251                         data->verdict.chain->use++;
4252                         break;
4253                 }
4254         }
4255 }
4256
4257 static void nft_set_elem_activate(const struct net *net,
4258                                   const struct nft_set *set,
4259                                   struct nft_set_elem *elem)
4260 {
4261         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
4262
4263         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA))
4264                 nft_data_hold(nft_set_ext_data(ext), set->dtype);
4265         if (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF))
4266                 (*nft_set_ext_obj(ext))->use++;
4267 }
4268
4269 static void nft_set_elem_deactivate(const struct net *net,
4270                                     const struct nft_set *set,
4271                                     struct nft_set_elem *elem)
4272 {
4273         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
4274
4275         if (nft_set_ext_exists(ext, NFT_SET_EXT_DATA))
4276                 nft_data_release(nft_set_ext_data(ext), set->dtype);
4277         if (nft_set_ext_exists(ext, NFT_SET_EXT_OBJREF))
4278                 (*nft_set_ext_obj(ext))->use--;
4279 }
4280
4281 static int nft_del_setelem(struct nft_ctx *ctx, struct nft_set *set,
4282                            const struct nlattr *attr)
4283 {
4284         struct nlattr *nla[NFTA_SET_ELEM_MAX + 1];
4285         struct nft_set_ext_tmpl tmpl;
4286         struct nft_set_elem elem;
4287         struct nft_set_ext *ext;
4288         struct nft_trans *trans;
4289         u32 flags = 0;
4290         void *priv;
4291         int err;
4292
4293         err = nla_parse_nested(nla, NFTA_SET_ELEM_MAX, attr,
4294                                nft_set_elem_policy, NULL);
4295         if (err < 0)
4296                 return err;
4297
4298         if (nla[NFTA_SET_ELEM_KEY] == NULL)
4299                 return -EINVAL;
4300
4301         nft_set_ext_prepare(&tmpl);
4302
4303         err = nft_setelem_parse_flags(set, nla[NFTA_SET_ELEM_FLAGS], &flags);
4304         if (err < 0)
4305                 return err;
4306         if (flags != 0)
4307                 nft_set_ext_add(&tmpl, NFT_SET_EXT_FLAGS);
4308
4309         err = nft_setelem_parse_key(ctx, set, &elem.key.val,
4310                                     nla[NFTA_SET_ELEM_KEY]);
4311         if (err < 0)
4312                 return err;
4313
4314         nft_set_ext_add_length(&tmpl, NFT_SET_EXT_KEY, set->klen);
4315
4316         err = -ENOMEM;
4317         elem.priv = nft_set_elem_init(set, &tmpl, elem.key.val.data, NULL, 0,
4318                                       GFP_KERNEL);
4319         if (elem.priv == NULL)
4320                 goto fail_elem;
4321
4322         ext = nft_set_elem_ext(set, elem.priv);
4323         if (flags)
4324                 *nft_set_ext_flags(ext) = flags;
4325
4326         trans = nft_trans_elem_alloc(ctx, NFT_MSG_DELSETELEM, set);
4327         if (trans == NULL)
4328                 goto fail_trans;
4329
4330         priv = set->ops->deactivate(ctx->net, set, &elem);
4331         if (priv == NULL) {
4332                 err = -ENOENT;
4333                 goto fail_ops;
4334         }
4335         kfree(elem.priv);
4336         elem.priv = priv;
4337
4338         nft_set_elem_deactivate(ctx->net, set, &elem);
4339
4340         nft_trans_elem(trans) = elem;
4341         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
4342         return 0;
4343
4344 fail_ops:
4345         kfree(trans);
4346 fail_trans:
4347         kfree(elem.priv);
4348 fail_elem:
4349         nft_data_release(&elem.key.val, NFT_DATA_VALUE);
4350         return err;
4351 }
4352
4353 static int nft_flush_set(const struct nft_ctx *ctx,
4354                          struct nft_set *set,
4355                          const struct nft_set_iter *iter,
4356                          struct nft_set_elem *elem)
4357 {
4358         struct nft_trans *trans;
4359         int err;
4360
4361         trans = nft_trans_alloc_gfp(ctx, NFT_MSG_DELSETELEM,
4362                                     sizeof(struct nft_trans_elem), GFP_ATOMIC);
4363         if (!trans)
4364                 return -ENOMEM;
4365
4366         if (!set->ops->flush(ctx->net, set, elem->priv)) {
4367                 err = -ENOENT;
4368                 goto err1;
4369         }
4370         set->ndeact++;
4371
4372         nft_set_elem_deactivate(ctx->net, set, elem);
4373         nft_trans_elem_set(trans) = set;
4374         nft_trans_elem(trans) = *elem;
4375         list_add_tail(&trans->list, &ctx->net->nft.commit_list);
4376
4377         return 0;
4378 err1:
4379         kfree(trans);
4380         return err;
4381 }
4382
4383 static int nf_tables_delsetelem(struct net *net, struct sock *nlsk,
4384                                 struct sk_buff *skb, const struct nlmsghdr *nlh,
4385                                 const struct nlattr * const nla[],
4386                                 struct netlink_ext_ack *extack)
4387 {
4388         u8 genmask = nft_genmask_next(net);
4389         const struct nlattr *attr;
4390         struct nft_set *set;
4391         struct nft_ctx ctx;
4392         int rem, err = 0;
4393
4394         err = nft_ctx_init_from_elemattr(&ctx, net, skb, nlh, nla, genmask);
4395         if (err < 0)
4396                 return err;
4397
4398         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET],
4399                                    genmask);
4400         if (IS_ERR(set))
4401                 return PTR_ERR(set);
4402         if (!list_empty(&set->bindings) && set->flags & NFT_SET_CONSTANT)
4403                 return -EBUSY;
4404
4405         if (nla[NFTA_SET_ELEM_LIST_ELEMENTS] == NULL) {
4406                 struct nft_set_iter iter = {
4407                         .genmask        = genmask,
4408                         .fn             = nft_flush_set,
4409                 };
4410                 set->ops->walk(&ctx, set, &iter);
4411
4412                 return iter.err;
4413         }
4414
4415         nla_for_each_nested(attr, nla[NFTA_SET_ELEM_LIST_ELEMENTS], rem) {
4416                 err = nft_del_setelem(&ctx, set, attr);
4417                 if (err < 0)
4418                         break;
4419
4420                 set->ndeact++;
4421         }
4422         return err;
4423 }
4424
4425 void nft_set_gc_batch_release(struct rcu_head *rcu)
4426 {
4427         struct nft_set_gc_batch *gcb;
4428         unsigned int i;
4429
4430         gcb = container_of(rcu, struct nft_set_gc_batch, head.rcu);
4431         for (i = 0; i < gcb->head.cnt; i++)
4432                 nft_set_elem_destroy(gcb->head.set, gcb->elems[i], true);
4433         kfree(gcb);
4434 }
4435 EXPORT_SYMBOL_GPL(nft_set_gc_batch_release);
4436
4437 struct nft_set_gc_batch *nft_set_gc_batch_alloc(const struct nft_set *set,
4438                                                 gfp_t gfp)
4439 {
4440         struct nft_set_gc_batch *gcb;
4441
4442         gcb = kzalloc(sizeof(*gcb), gfp);
4443         if (gcb == NULL)
4444                 return gcb;
4445         gcb->head.set = set;
4446         return gcb;
4447 }
4448 EXPORT_SYMBOL_GPL(nft_set_gc_batch_alloc);
4449
4450 /*
4451  * Stateful objects
4452  */
4453
4454 /**
4455  *      nft_register_obj- register nf_tables stateful object type
4456  *      @obj: object type
4457  *
4458  *      Registers the object type for use with nf_tables. Returns zero on
4459  *      success or a negative errno code otherwise.
4460  */
4461 int nft_register_obj(struct nft_object_type *obj_type)
4462 {
4463         if (obj_type->type == NFT_OBJECT_UNSPEC)
4464                 return -EINVAL;
4465
4466         nfnl_lock(NFNL_SUBSYS_NFTABLES);
4467         list_add_rcu(&obj_type->list, &nf_tables_objects);
4468         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
4469         return 0;
4470 }
4471 EXPORT_SYMBOL_GPL(nft_register_obj);
4472
4473 /**
4474  *      nft_unregister_obj - unregister nf_tables object type
4475  *      @obj: object type
4476  *
4477  *      Unregisters the object type for use with nf_tables.
4478  */
4479 void nft_unregister_obj(struct nft_object_type *obj_type)
4480 {
4481         nfnl_lock(NFNL_SUBSYS_NFTABLES);
4482         list_del_rcu(&obj_type->list);
4483         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
4484 }
4485 EXPORT_SYMBOL_GPL(nft_unregister_obj);
4486
4487 struct nft_object *nf_tables_obj_lookup(const struct nft_table *table,
4488                                         const struct nlattr *nla,
4489                                         u32 objtype, u8 genmask)
4490 {
4491         struct nft_object *obj;
4492
4493         list_for_each_entry(obj, &table->objects, list) {
4494                 if (!nla_strcmp(nla, obj->name) &&
4495                     objtype == obj->ops->type->type &&
4496                     nft_active_genmask(obj, genmask))
4497                         return obj;
4498         }
4499         return ERR_PTR(-ENOENT);
4500 }
4501 EXPORT_SYMBOL_GPL(nf_tables_obj_lookup);
4502
4503 static const struct nla_policy nft_obj_policy[NFTA_OBJ_MAX + 1] = {
4504         [NFTA_OBJ_TABLE]        = { .type = NLA_STRING,
4505                                     .len = NFT_TABLE_MAXNAMELEN - 1 },
4506         [NFTA_OBJ_NAME]         = { .type = NLA_STRING,
4507                                     .len = NFT_OBJ_MAXNAMELEN - 1 },
4508         [NFTA_OBJ_TYPE]         = { .type = NLA_U32 },
4509         [NFTA_OBJ_DATA]         = { .type = NLA_NESTED },
4510 };
4511
4512 static struct nft_object *nft_obj_init(const struct nft_ctx *ctx,
4513                                        const struct nft_object_type *type,
4514                                        const struct nlattr *attr)
4515 {
4516         struct nlattr *tb[type->maxattr + 1];
4517         const struct nft_object_ops *ops;
4518         struct nft_object *obj;
4519         int err;
4520
4521         if (attr) {
4522                 err = nla_parse_nested(tb, type->maxattr, attr, type->policy,
4523                                        NULL);
4524                 if (err < 0)
4525                         goto err1;
4526         } else {
4527                 memset(tb, 0, sizeof(tb[0]) * (type->maxattr + 1));
4528         }
4529
4530         if (type->select_ops) {
4531                 ops = type->select_ops(ctx, (const struct nlattr * const *)tb);
4532                 if (IS_ERR(ops)) {
4533                         err = PTR_ERR(ops);
4534                         goto err1;
4535                 }
4536         } else {
4537                 ops = type->ops;
4538         }
4539
4540         err = -ENOMEM;
4541         obj = kzalloc(sizeof(*obj) + ops->size, GFP_KERNEL);
4542         if (obj == NULL)
4543                 goto err1;
4544
4545         err = ops->init(ctx, (const struct nlattr * const *)tb, obj);
4546         if (err < 0)
4547                 goto err2;
4548
4549         obj->ops = ops;
4550
4551         return obj;
4552 err2:
4553         kfree(obj);
4554 err1:
4555         return ERR_PTR(err);
4556 }
4557
4558 static int nft_object_dump(struct sk_buff *skb, unsigned int attr,
4559                            struct nft_object *obj, bool reset)
4560 {
4561         struct nlattr *nest;
4562
4563         nest = nla_nest_start(skb, attr);
4564         if (!nest)
4565                 goto nla_put_failure;
4566         if (obj->ops->dump(skb, obj, reset) < 0)
4567                 goto nla_put_failure;
4568         nla_nest_end(skb, nest);
4569         return 0;
4570
4571 nla_put_failure:
4572         return -1;
4573 }
4574
4575 static const struct nft_object_type *__nft_obj_type_get(u32 objtype)
4576 {
4577         const struct nft_object_type *type;
4578
4579         list_for_each_entry(type, &nf_tables_objects, list) {
4580                 if (objtype == type->type)
4581                         return type;
4582         }
4583         return NULL;
4584 }
4585
4586 static const struct nft_object_type *nft_obj_type_get(u32 objtype)
4587 {
4588         const struct nft_object_type *type;
4589
4590         type = __nft_obj_type_get(objtype);
4591         if (type != NULL && try_module_get(type->owner))
4592                 return type;
4593
4594 #ifdef CONFIG_MODULES
4595         if (type == NULL) {
4596                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
4597                 request_module("nft-obj-%u", objtype);
4598                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
4599                 if (__nft_obj_type_get(objtype))
4600                         return ERR_PTR(-EAGAIN);
4601         }
4602 #endif
4603         return ERR_PTR(-ENOENT);
4604 }
4605
4606 static int nf_tables_newobj(struct net *net, struct sock *nlsk,
4607                             struct sk_buff *skb, const struct nlmsghdr *nlh,
4608                             const struct nlattr * const nla[],
4609                             struct netlink_ext_ack *extack)
4610 {
4611         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
4612         const struct nft_object_type *type;
4613         u8 genmask = nft_genmask_next(net);
4614         int family = nfmsg->nfgen_family;
4615         struct nft_af_info *afi;
4616         struct nft_table *table;
4617         struct nft_object *obj;
4618         struct nft_ctx ctx;
4619         u32 objtype;
4620         int err;
4621
4622         if (!nla[NFTA_OBJ_TYPE] ||
4623             !nla[NFTA_OBJ_NAME] ||
4624             !nla[NFTA_OBJ_DATA])
4625                 return -EINVAL;
4626
4627         afi = nf_tables_afinfo_lookup(net, family, true);
4628         if (IS_ERR(afi))
4629                 return PTR_ERR(afi);
4630
4631         table = nf_tables_table_lookup(afi, nla[NFTA_OBJ_TABLE], genmask);
4632         if (IS_ERR(table))
4633                 return PTR_ERR(table);
4634
4635         objtype = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE]));
4636         obj = nf_tables_obj_lookup(table, nla[NFTA_OBJ_NAME], objtype, genmask);
4637         if (IS_ERR(obj)) {
4638                 err = PTR_ERR(obj);
4639                 if (err != -ENOENT)
4640                         return err;
4641
4642         } else {
4643                 if (nlh->nlmsg_flags & NLM_F_EXCL)
4644                         return -EEXIST;
4645
4646                 return 0;
4647         }
4648
4649         nft_ctx_init(&ctx, net, skb, nlh, afi, table, NULL, nla);
4650
4651         type = nft_obj_type_get(objtype);
4652         if (IS_ERR(type))
4653                 return PTR_ERR(type);
4654
4655         obj = nft_obj_init(&ctx, type, nla[NFTA_OBJ_DATA]);
4656         if (IS_ERR(obj)) {
4657                 err = PTR_ERR(obj);
4658                 goto err1;
4659         }
4660         obj->table = table;
4661         obj->name = nla_strdup(nla[NFTA_OBJ_NAME], GFP_KERNEL);
4662         if (!obj->name) {
4663                 err = -ENOMEM;
4664                 goto err2;
4665         }
4666
4667         err = nft_trans_obj_add(&ctx, NFT_MSG_NEWOBJ, obj);
4668         if (err < 0)
4669                 goto err3;
4670
4671         list_add_tail_rcu(&obj->list, &table->objects);
4672         table->use++;
4673         return 0;
4674 err3:
4675         kfree(obj->name);
4676 err2:
4677         if (obj->ops->destroy)
4678                 obj->ops->destroy(obj);
4679         kfree(obj);
4680 err1:
4681         module_put(type->owner);
4682         return err;
4683 }
4684
4685 static int nf_tables_fill_obj_info(struct sk_buff *skb, struct net *net,
4686                                    u32 portid, u32 seq, int event, u32 flags,
4687                                    int family, const struct nft_table *table,
4688                                    struct nft_object *obj, bool reset)
4689 {
4690         struct nfgenmsg *nfmsg;
4691         struct nlmsghdr *nlh;
4692
4693         event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, event);
4694         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags);
4695         if (nlh == NULL)
4696                 goto nla_put_failure;
4697
4698         nfmsg = nlmsg_data(nlh);
4699         nfmsg->nfgen_family     = family;
4700         nfmsg->version          = NFNETLINK_V0;
4701         nfmsg->res_id           = htons(net->nft.base_seq & 0xffff);
4702
4703         if (nla_put_string(skb, NFTA_OBJ_TABLE, table->name) ||
4704             nla_put_string(skb, NFTA_OBJ_NAME, obj->name) ||
4705             nla_put_be32(skb, NFTA_OBJ_TYPE, htonl(obj->ops->type->type)) ||
4706             nla_put_be32(skb, NFTA_OBJ_USE, htonl(obj->use)) ||
4707             nft_object_dump(skb, NFTA_OBJ_DATA, obj, reset))
4708                 goto nla_put_failure;
4709
4710         nlmsg_end(skb, nlh);
4711         return 0;
4712
4713 nla_put_failure:
4714         nlmsg_trim(skb, nlh);
4715         return -1;
4716 }
4717
4718 struct nft_obj_filter {
4719         char            *table;
4720         u32             type;
4721 };
4722
4723 static int nf_tables_dump_obj(struct sk_buff *skb, struct netlink_callback *cb)
4724 {
4725         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
4726         const struct nft_af_info *afi;
4727         const struct nft_table *table;
4728         unsigned int idx = 0, s_idx = cb->args[0];
4729         struct nft_obj_filter *filter = cb->data;
4730         struct net *net = sock_net(skb->sk);
4731         int family = nfmsg->nfgen_family;
4732         struct nft_object *obj;
4733         bool reset = false;
4734
4735         if (NFNL_MSG_TYPE(cb->nlh->nlmsg_type) == NFT_MSG_GETOBJ_RESET)
4736                 reset = true;
4737
4738         rcu_read_lock();
4739         cb->seq = net->nft.base_seq;
4740
4741         list_for_each_entry_rcu(afi, &net->nft.af_info, list) {
4742                 if (family != NFPROTO_UNSPEC && family != afi->family)
4743                         continue;
4744
4745                 list_for_each_entry_rcu(table, &afi->tables, list) {
4746                         list_for_each_entry_rcu(obj, &table->objects, list) {
4747                                 if (!nft_is_active(net, obj))
4748                                         goto cont;
4749                                 if (idx < s_idx)
4750                                         goto cont;
4751                                 if (idx > s_idx)
4752                                         memset(&cb->args[1], 0,
4753                                                sizeof(cb->args) - sizeof(cb->args[0]));
4754                                 if (filter && filter->table &&
4755                                     strcmp(filter->table, table->name))
4756                                         goto cont;
4757                                 if (filter &&
4758                                     filter->type != NFT_OBJECT_UNSPEC &&
4759                                     obj->ops->type->type != filter->type)
4760                                         goto cont;
4761
4762                                 if (nf_tables_fill_obj_info(skb, net, NETLINK_CB(cb->skb).portid,
4763                                                             cb->nlh->nlmsg_seq,
4764                                                             NFT_MSG_NEWOBJ,
4765                                                             NLM_F_MULTI | NLM_F_APPEND,
4766                                                             afi->family, table, obj, reset) < 0)
4767                                         goto done;
4768
4769                                 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
4770 cont:
4771                                 idx++;
4772                         }
4773                 }
4774         }
4775 done:
4776         rcu_read_unlock();
4777
4778         cb->args[0] = idx;
4779         return skb->len;
4780 }
4781
4782 static int nf_tables_dump_obj_done(struct netlink_callback *cb)
4783 {
4784         struct nft_obj_filter *filter = cb->data;
4785
4786         if (filter) {
4787                 kfree(filter->table);
4788                 kfree(filter);
4789         }
4790
4791         return 0;
4792 }
4793
4794 static struct nft_obj_filter *
4795 nft_obj_filter_alloc(const struct nlattr * const nla[])
4796 {
4797         struct nft_obj_filter *filter;
4798
4799         filter = kzalloc(sizeof(*filter), GFP_KERNEL);
4800         if (!filter)
4801                 return ERR_PTR(-ENOMEM);
4802
4803         if (nla[NFTA_OBJ_TABLE]) {
4804                 filter->table = nla_strdup(nla[NFTA_OBJ_TABLE], GFP_KERNEL);
4805                 if (!filter->table) {
4806                         kfree(filter);
4807                         return ERR_PTR(-ENOMEM);
4808                 }
4809         }
4810         if (nla[NFTA_OBJ_TYPE])
4811                 filter->type = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE]));
4812
4813         return filter;
4814 }
4815
4816 static int nf_tables_getobj(struct net *net, struct sock *nlsk,
4817                             struct sk_buff *skb, const struct nlmsghdr *nlh,
4818                             const struct nlattr * const nla[],
4819                             struct netlink_ext_ack *extack)
4820 {
4821         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
4822         u8 genmask = nft_genmask_cur(net);
4823         int family = nfmsg->nfgen_family;
4824         const struct nft_af_info *afi;
4825         const struct nft_table *table;
4826         struct nft_object *obj;
4827         struct sk_buff *skb2;
4828         bool reset = false;
4829         u32 objtype;
4830         int err;
4831
4832         if (nlh->nlmsg_flags & NLM_F_DUMP) {
4833                 struct netlink_dump_control c = {
4834                         .dump = nf_tables_dump_obj,
4835                         .done = nf_tables_dump_obj_done,
4836                 };
4837
4838                 if (nla[NFTA_OBJ_TABLE] ||
4839                     nla[NFTA_OBJ_TYPE]) {
4840                         struct nft_obj_filter *filter;
4841
4842                         filter = nft_obj_filter_alloc(nla);
4843                         if (IS_ERR(filter))
4844                                 return -ENOMEM;
4845
4846                         c.data = filter;
4847                 }
4848                 return netlink_dump_start(nlsk, skb, nlh, &c);
4849         }
4850
4851         if (!nla[NFTA_OBJ_NAME] ||
4852             !nla[NFTA_OBJ_TYPE])
4853                 return -EINVAL;
4854
4855         afi = nf_tables_afinfo_lookup(net, family, false);
4856         if (IS_ERR(afi))
4857                 return PTR_ERR(afi);
4858
4859         table = nf_tables_table_lookup(afi, nla[NFTA_OBJ_TABLE], genmask);
4860         if (IS_ERR(table))
4861                 return PTR_ERR(table);
4862
4863         objtype = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE]));
4864         obj = nf_tables_obj_lookup(table, nla[NFTA_OBJ_NAME], objtype, genmask);
4865         if (IS_ERR(obj))
4866                 return PTR_ERR(obj);
4867
4868         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
4869         if (!skb2)
4870                 return -ENOMEM;
4871
4872         if (NFNL_MSG_TYPE(nlh->nlmsg_type) == NFT_MSG_GETOBJ_RESET)
4873                 reset = true;
4874
4875         err = nf_tables_fill_obj_info(skb2, net, NETLINK_CB(skb).portid,
4876                                       nlh->nlmsg_seq, NFT_MSG_NEWOBJ, 0,
4877                                       family, table, obj, reset);
4878         if (err < 0)
4879                 goto err;
4880
4881         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
4882 err:
4883         kfree_skb(skb2);
4884         return err;
4885 }
4886
4887 static void nft_obj_destroy(struct nft_object *obj)
4888 {
4889         if (obj->ops->destroy)
4890                 obj->ops->destroy(obj);
4891
4892         module_put(obj->ops->type->owner);
4893         kfree(obj->name);
4894         kfree(obj);
4895 }
4896
4897 static int nf_tables_delobj(struct net *net, struct sock *nlsk,
4898                             struct sk_buff *skb, const struct nlmsghdr *nlh,
4899                             const struct nlattr * const nla[],
4900                             struct netlink_ext_ack *extack)
4901 {
4902         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
4903         u8 genmask = nft_genmask_next(net);
4904         int family = nfmsg->nfgen_family;
4905         struct nft_af_info *afi;
4906         struct nft_table *table;
4907         struct nft_object *obj;
4908         struct nft_ctx ctx;
4909         u32 objtype;
4910
4911         if (!nla[NFTA_OBJ_TYPE] ||
4912             !nla[NFTA_OBJ_NAME])
4913                 return -EINVAL;
4914
4915         afi = nf_tables_afinfo_lookup(net, family, true);
4916         if (IS_ERR(afi))
4917                 return PTR_ERR(afi);
4918
4919         table = nf_tables_table_lookup(afi, nla[NFTA_OBJ_TABLE], genmask);
4920         if (IS_ERR(table))
4921                 return PTR_ERR(table);
4922
4923         objtype = ntohl(nla_get_be32(nla[NFTA_OBJ_TYPE]));
4924         obj = nf_tables_obj_lookup(table, nla[NFTA_OBJ_NAME], objtype, genmask);
4925         if (IS_ERR(obj))
4926                 return PTR_ERR(obj);
4927         if (obj->use > 0)
4928                 return -EBUSY;
4929
4930         nft_ctx_init(&ctx, net, skb, nlh, afi, table, NULL, nla);
4931
4932         return nft_delobj(&ctx, obj);
4933 }
4934
4935 void nft_obj_notify(struct net *net, struct nft_table *table,
4936                     struct nft_object *obj, u32 portid, u32 seq, int event,
4937                     int family, int report, gfp_t gfp)
4938 {
4939         struct sk_buff *skb;
4940         int err;
4941
4942         if (!report &&
4943             !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
4944                 return;
4945
4946         skb = nlmsg_new(NLMSG_GOODSIZE, gfp);
4947         if (skb == NULL)
4948                 goto err;
4949
4950         err = nf_tables_fill_obj_info(skb, net, portid, seq, event, 0, family,
4951                                       table, obj, false);
4952         if (err < 0) {
4953                 kfree_skb(skb);
4954                 goto err;
4955         }
4956
4957         nfnetlink_send(skb, net, portid, NFNLGRP_NFTABLES, report, gfp);
4958         return;
4959 err:
4960         nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, -ENOBUFS);
4961 }
4962 EXPORT_SYMBOL_GPL(nft_obj_notify);
4963
4964 static void nf_tables_obj_notify(const struct nft_ctx *ctx,
4965                                  struct nft_object *obj, int event)
4966 {
4967         nft_obj_notify(ctx->net, ctx->table, obj, ctx->portid, ctx->seq, event,
4968                        ctx->afi->family, ctx->report, GFP_KERNEL);
4969 }
4970
4971 static int nf_tables_fill_gen_info(struct sk_buff *skb, struct net *net,
4972                                    u32 portid, u32 seq)
4973 {
4974         struct nlmsghdr *nlh;
4975         struct nfgenmsg *nfmsg;
4976         char buf[TASK_COMM_LEN];
4977         int event = nfnl_msg_type(NFNL_SUBSYS_NFTABLES, NFT_MSG_NEWGEN);
4978
4979         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), 0);
4980         if (nlh == NULL)
4981                 goto nla_put_failure;
4982
4983         nfmsg = nlmsg_data(nlh);
4984         nfmsg->nfgen_family     = AF_UNSPEC;
4985         nfmsg->version          = NFNETLINK_V0;
4986         nfmsg->res_id           = htons(net->nft.base_seq & 0xffff);
4987
4988         if (nla_put_be32(skb, NFTA_GEN_ID, htonl(net->nft.base_seq)) ||
4989             nla_put_be32(skb, NFTA_GEN_PROC_PID, htonl(task_pid_nr(current))) ||
4990             nla_put_string(skb, NFTA_GEN_PROC_NAME, get_task_comm(buf, current)))
4991                 goto nla_put_failure;
4992
4993         nlmsg_end(skb, nlh);
4994         return 0;
4995
4996 nla_put_failure:
4997         nlmsg_trim(skb, nlh);
4998         return -EMSGSIZE;
4999 }
5000
5001 static void nf_tables_gen_notify(struct net *net, struct sk_buff *skb,
5002                                  int event)
5003 {
5004         struct nlmsghdr *nlh = nlmsg_hdr(skb);
5005         struct sk_buff *skb2;
5006         int err;
5007
5008         if (nlmsg_report(nlh) &&
5009             !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
5010                 return;
5011
5012         skb2 = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
5013         if (skb2 == NULL)
5014                 goto err;
5015
5016         err = nf_tables_fill_gen_info(skb2, net, NETLINK_CB(skb).portid,
5017                                       nlh->nlmsg_seq);
5018         if (err < 0) {
5019                 kfree_skb(skb2);
5020                 goto err;
5021         }
5022
5023         nfnetlink_send(skb2, net, NETLINK_CB(skb).portid, NFNLGRP_NFTABLES,
5024                        nlmsg_report(nlh), GFP_KERNEL);
5025         return;
5026 err:
5027         nfnetlink_set_err(net, NETLINK_CB(skb).portid, NFNLGRP_NFTABLES,
5028                           -ENOBUFS);
5029 }
5030
5031 static int nf_tables_getgen(struct net *net, struct sock *nlsk,
5032                             struct sk_buff *skb, const struct nlmsghdr *nlh,
5033                             const struct nlattr * const nla[],
5034                             struct netlink_ext_ack *extack)
5035 {
5036         struct sk_buff *skb2;
5037         int err;
5038
5039         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
5040         if (skb2 == NULL)
5041                 return -ENOMEM;
5042
5043         err = nf_tables_fill_gen_info(skb2, net, NETLINK_CB(skb).portid,
5044                                       nlh->nlmsg_seq);
5045         if (err < 0)
5046                 goto err;
5047
5048         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
5049 err:
5050         kfree_skb(skb2);
5051         return err;
5052 }
5053
5054 static const struct nfnl_callback nf_tables_cb[NFT_MSG_MAX] = {
5055         [NFT_MSG_NEWTABLE] = {
5056                 .call_batch     = nf_tables_newtable,
5057                 .attr_count     = NFTA_TABLE_MAX,
5058                 .policy         = nft_table_policy,
5059         },
5060         [NFT_MSG_GETTABLE] = {
5061                 .call           = nf_tables_gettable,
5062                 .attr_count     = NFTA_TABLE_MAX,
5063                 .policy         = nft_table_policy,
5064         },
5065         [NFT_MSG_DELTABLE] = {
5066                 .call_batch     = nf_tables_deltable,
5067                 .attr_count     = NFTA_TABLE_MAX,
5068                 .policy         = nft_table_policy,
5069         },
5070         [NFT_MSG_NEWCHAIN] = {
5071                 .call_batch     = nf_tables_newchain,
5072                 .attr_count     = NFTA_CHAIN_MAX,
5073                 .policy         = nft_chain_policy,
5074         },
5075         [NFT_MSG_GETCHAIN] = {
5076                 .call           = nf_tables_getchain,
5077                 .attr_count     = NFTA_CHAIN_MAX,
5078                 .policy         = nft_chain_policy,
5079         },
5080         [NFT_MSG_DELCHAIN] = {
5081                 .call_batch     = nf_tables_delchain,
5082                 .attr_count     = NFTA_CHAIN_MAX,
5083                 .policy         = nft_chain_policy,
5084         },
5085         [NFT_MSG_NEWRULE] = {
5086                 .call_batch     = nf_tables_newrule,
5087                 .attr_count     = NFTA_RULE_MAX,
5088                 .policy         = nft_rule_policy,
5089         },
5090         [NFT_MSG_GETRULE] = {
5091                 .call           = nf_tables_getrule,
5092                 .attr_count     = NFTA_RULE_MAX,
5093                 .policy         = nft_rule_policy,
5094         },
5095         [NFT_MSG_DELRULE] = {
5096                 .call_batch     = nf_tables_delrule,
5097                 .attr_count     = NFTA_RULE_MAX,
5098                 .policy         = nft_rule_policy,
5099         },
5100         [NFT_MSG_NEWSET] = {
5101                 .call_batch     = nf_tables_newset,
5102                 .attr_count     = NFTA_SET_MAX,
5103                 .policy         = nft_set_policy,
5104         },
5105         [NFT_MSG_GETSET] = {
5106                 .call           = nf_tables_getset,
5107                 .attr_count     = NFTA_SET_MAX,
5108                 .policy         = nft_set_policy,
5109         },
5110         [NFT_MSG_DELSET] = {
5111                 .call_batch     = nf_tables_delset,
5112                 .attr_count     = NFTA_SET_MAX,
5113                 .policy         = nft_set_policy,
5114         },
5115         [NFT_MSG_NEWSETELEM] = {
5116                 .call_batch     = nf_tables_newsetelem,
5117                 .attr_count     = NFTA_SET_ELEM_LIST_MAX,
5118                 .policy         = nft_set_elem_list_policy,
5119         },
5120         [NFT_MSG_GETSETELEM] = {
5121                 .call           = nf_tables_getsetelem,
5122                 .attr_count     = NFTA_SET_ELEM_LIST_MAX,
5123                 .policy         = nft_set_elem_list_policy,
5124         },
5125         [NFT_MSG_DELSETELEM] = {
5126                 .call_batch     = nf_tables_delsetelem,
5127                 .attr_count     = NFTA_SET_ELEM_LIST_MAX,
5128                 .policy         = nft_set_elem_list_policy,
5129         },
5130         [NFT_MSG_GETGEN] = {
5131                 .call           = nf_tables_getgen,
5132         },
5133         [NFT_MSG_NEWOBJ] = {
5134                 .call_batch     = nf_tables_newobj,
5135                 .attr_count     = NFTA_OBJ_MAX,
5136                 .policy         = nft_obj_policy,
5137         },
5138         [NFT_MSG_GETOBJ] = {
5139                 .call           = nf_tables_getobj,
5140                 .attr_count     = NFTA_OBJ_MAX,
5141                 .policy         = nft_obj_policy,
5142         },
5143         [NFT_MSG_DELOBJ] = {
5144                 .call_batch     = nf_tables_delobj,
5145                 .attr_count     = NFTA_OBJ_MAX,
5146                 .policy         = nft_obj_policy,
5147         },
5148         [NFT_MSG_GETOBJ_RESET] = {
5149                 .call           = nf_tables_getobj,
5150                 .attr_count     = NFTA_OBJ_MAX,
5151                 .policy         = nft_obj_policy,
5152         },
5153 };
5154
5155 static void nft_chain_commit_update(struct nft_trans *trans)
5156 {
5157         struct nft_base_chain *basechain;
5158
5159         if (nft_trans_chain_name(trans))
5160                 swap(trans->ctx.chain->name, nft_trans_chain_name(trans));
5161
5162         if (!nft_is_base_chain(trans->ctx.chain))
5163                 return;
5164
5165         basechain = nft_base_chain(trans->ctx.chain);
5166         nft_chain_stats_replace(basechain, nft_trans_chain_stats(trans));
5167
5168         switch (nft_trans_chain_policy(trans)) {
5169         case NF_DROP:
5170         case NF_ACCEPT:
5171                 basechain->policy = nft_trans_chain_policy(trans);
5172                 break;
5173         }
5174 }
5175
5176 static void nf_tables_commit_release(struct nft_trans *trans)
5177 {
5178         switch (trans->msg_type) {
5179         case NFT_MSG_DELTABLE:
5180                 nf_tables_table_destroy(&trans->ctx);
5181                 break;
5182         case NFT_MSG_NEWCHAIN:
5183                 kfree(nft_trans_chain_name(trans));
5184                 break;
5185         case NFT_MSG_DELCHAIN:
5186                 nf_tables_chain_destroy(trans->ctx.chain);
5187                 break;
5188         case NFT_MSG_DELRULE:
5189                 nf_tables_rule_destroy(&trans->ctx, nft_trans_rule(trans));
5190                 break;
5191         case NFT_MSG_DELSET:
5192                 nft_set_destroy(nft_trans_set(trans));
5193                 break;
5194         case NFT_MSG_DELSETELEM:
5195                 nf_tables_set_elem_destroy(nft_trans_elem_set(trans),
5196                                            nft_trans_elem(trans).priv);
5197                 break;
5198         case NFT_MSG_DELOBJ:
5199                 nft_obj_destroy(nft_trans_obj(trans));
5200                 break;
5201         }
5202         kfree(trans);
5203 }
5204
5205 static int nf_tables_commit(struct net *net, struct sk_buff *skb)
5206 {
5207         struct nft_trans *trans, *next;
5208         struct nft_trans_elem *te;
5209
5210         /* Bump generation counter, invalidate any dump in progress */
5211         while (++net->nft.base_seq == 0);
5212
5213         /* A new generation has just started */
5214         net->nft.gencursor = nft_gencursor_next(net);
5215
5216         /* Make sure all packets have left the previous generation before
5217          * purging old rules.
5218          */
5219         synchronize_rcu();
5220
5221         list_for_each_entry_safe(trans, next, &net->nft.commit_list, list) {
5222                 switch (trans->msg_type) {
5223                 case NFT_MSG_NEWTABLE:
5224                         if (nft_trans_table_update(trans)) {
5225                                 if (!nft_trans_table_enable(trans)) {
5226                                         nf_tables_table_disable(net,
5227                                                                 trans->ctx.afi,
5228                                                                 trans->ctx.table);
5229                                         trans->ctx.table->flags |= NFT_TABLE_F_DORMANT;
5230                                 }
5231                         } else {
5232                                 nft_clear(net, trans->ctx.table);
5233                         }
5234                         nf_tables_table_notify(&trans->ctx, NFT_MSG_NEWTABLE);
5235                         nft_trans_destroy(trans);
5236                         break;
5237                 case NFT_MSG_DELTABLE:
5238                         list_del_rcu(&trans->ctx.table->list);
5239                         nf_tables_table_notify(&trans->ctx, NFT_MSG_DELTABLE);
5240                         break;
5241                 case NFT_MSG_NEWCHAIN:
5242                         if (nft_trans_chain_update(trans)) {
5243                                 nft_chain_commit_update(trans);
5244                                 nf_tables_chain_notify(&trans->ctx, NFT_MSG_NEWCHAIN);
5245                                 /* trans destroyed after rcu grace period */
5246                         } else {
5247                                 nft_clear(net, trans->ctx.chain);
5248                                 nf_tables_chain_notify(&trans->ctx, NFT_MSG_NEWCHAIN);
5249                                 nft_trans_destroy(trans);
5250                         }
5251                         break;
5252                 case NFT_MSG_DELCHAIN:
5253                         list_del_rcu(&trans->ctx.chain->list);
5254                         nf_tables_chain_notify(&trans->ctx, NFT_MSG_DELCHAIN);
5255                         nf_tables_unregister_hooks(trans->ctx.net,
5256                                                    trans->ctx.table,
5257                                                    trans->ctx.chain,
5258                                                    trans->ctx.afi->nops);
5259                         break;
5260                 case NFT_MSG_NEWRULE:
5261                         nft_clear(trans->ctx.net, nft_trans_rule(trans));
5262                         nf_tables_rule_notify(&trans->ctx,
5263                                               nft_trans_rule(trans),
5264                                               NFT_MSG_NEWRULE);
5265                         nft_trans_destroy(trans);
5266                         break;
5267                 case NFT_MSG_DELRULE:
5268                         list_del_rcu(&nft_trans_rule(trans)->list);
5269                         nf_tables_rule_notify(&trans->ctx,
5270                                               nft_trans_rule(trans),
5271                                               NFT_MSG_DELRULE);
5272                         nft_rule_expr_deactivate(&trans->ctx,
5273                                                  nft_trans_rule(trans),
5274                                                  NFT_TRANS_COMMIT);
5275                         break;
5276                 case NFT_MSG_NEWSET:
5277                         nft_clear(net, nft_trans_set(trans));
5278                         /* This avoids hitting -EBUSY when deleting the table
5279                          * from the transaction.
5280                          */
5281                         if (nft_trans_set(trans)->flags & NFT_SET_ANONYMOUS &&
5282                             !list_empty(&nft_trans_set(trans)->bindings))
5283                                 trans->ctx.table->use--;
5284
5285                         nf_tables_set_notify(&trans->ctx, nft_trans_set(trans),
5286                                              NFT_MSG_NEWSET, GFP_KERNEL);
5287                         nft_trans_destroy(trans);
5288                         break;
5289                 case NFT_MSG_DELSET:
5290                         list_del_rcu(&nft_trans_set(trans)->list);
5291                         nf_tables_set_notify(&trans->ctx, nft_trans_set(trans),
5292                                              NFT_MSG_DELSET, GFP_KERNEL);
5293                         break;
5294                 case NFT_MSG_NEWSETELEM:
5295                         te = (struct nft_trans_elem *)trans->data;
5296
5297                         te->set->ops->activate(net, te->set, &te->elem);
5298                         nf_tables_setelem_notify(&trans->ctx, te->set,
5299                                                  &te->elem,
5300                                                  NFT_MSG_NEWSETELEM, 0);
5301                         nft_trans_destroy(trans);
5302                         break;
5303                 case NFT_MSG_DELSETELEM:
5304                         te = (struct nft_trans_elem *)trans->data;
5305
5306                         nf_tables_setelem_notify(&trans->ctx, te->set,
5307                                                  &te->elem,
5308                                                  NFT_MSG_DELSETELEM, 0);
5309                         te->set->ops->remove(net, te->set, &te->elem);
5310                         atomic_dec(&te->set->nelems);
5311                         te->set->ndeact--;
5312                         break;
5313                 case NFT_MSG_NEWOBJ:
5314                         nft_clear(net, nft_trans_obj(trans));
5315                         nf_tables_obj_notify(&trans->ctx, nft_trans_obj(trans),
5316                                              NFT_MSG_NEWOBJ);
5317                         nft_trans_destroy(trans);
5318                         break;
5319                 case NFT_MSG_DELOBJ:
5320                         list_del_rcu(&nft_trans_obj(trans)->list);
5321                         nf_tables_obj_notify(&trans->ctx, nft_trans_obj(trans),
5322                                              NFT_MSG_DELOBJ);
5323                         break;
5324                 }
5325         }
5326
5327         synchronize_rcu();
5328
5329         list_for_each_entry_safe(trans, next, &net->nft.commit_list, list) {
5330                 list_del(&trans->list);
5331                 nf_tables_commit_release(trans);
5332         }
5333
5334         nf_tables_gen_notify(net, skb, NFT_MSG_NEWGEN);
5335
5336         return 0;
5337 }
5338
5339 static void nf_tables_abort_release(struct nft_trans *trans)
5340 {
5341         switch (trans->msg_type) {
5342         case NFT_MSG_NEWTABLE:
5343                 nf_tables_table_destroy(&trans->ctx);
5344                 break;
5345         case NFT_MSG_NEWCHAIN:
5346                 nf_tables_chain_destroy(trans->ctx.chain);
5347                 break;
5348         case NFT_MSG_NEWRULE:
5349                 nf_tables_rule_destroy(&trans->ctx, nft_trans_rule(trans));
5350                 break;
5351         case NFT_MSG_NEWSET:
5352                 if (!nft_trans_set_bound(trans))
5353                         nft_set_destroy(nft_trans_set(trans));
5354                 break;
5355         case NFT_MSG_NEWSETELEM:
5356                 nft_set_elem_destroy(nft_trans_elem_set(trans),
5357                                      nft_trans_elem(trans).priv, true);
5358                 break;
5359         case NFT_MSG_NEWOBJ:
5360                 nft_obj_destroy(nft_trans_obj(trans));
5361                 break;
5362         }
5363         kfree(trans);
5364 }
5365
5366 static int nf_tables_abort(struct net *net, struct sk_buff *skb)
5367 {
5368         struct nft_trans *trans, *next;
5369         struct nft_trans_elem *te;
5370
5371         list_for_each_entry_safe_reverse(trans, next, &net->nft.commit_list,
5372                                          list) {
5373                 switch (trans->msg_type) {
5374                 case NFT_MSG_NEWTABLE:
5375                         if (nft_trans_table_update(trans)) {
5376                                 if (nft_trans_table_enable(trans)) {
5377                                         nf_tables_table_disable(net,
5378                                                                 trans->ctx.afi,
5379                                                                 trans->ctx.table);
5380                                         trans->ctx.table->flags |= NFT_TABLE_F_DORMANT;
5381                                 }
5382                                 nft_trans_destroy(trans);
5383                         } else {
5384                                 list_del_rcu(&trans->ctx.table->list);
5385                         }
5386                         break;
5387                 case NFT_MSG_DELTABLE:
5388                         nft_clear(trans->ctx.net, trans->ctx.table);
5389                         nft_trans_destroy(trans);
5390                         break;
5391                 case NFT_MSG_NEWCHAIN:
5392                         if (nft_trans_chain_update(trans)) {
5393                                 free_percpu(nft_trans_chain_stats(trans));
5394                                 kfree(nft_trans_chain_name(trans));
5395                                 nft_trans_destroy(trans);
5396                         } else {
5397                                 trans->ctx.table->use--;
5398                                 list_del_rcu(&trans->ctx.chain->list);
5399                                 nf_tables_unregister_hooks(trans->ctx.net,
5400                                                            trans->ctx.table,
5401                                                            trans->ctx.chain,
5402                                                            trans->ctx.afi->nops);
5403                         }
5404                         break;
5405                 case NFT_MSG_DELCHAIN:
5406                         trans->ctx.table->use++;
5407                         nft_clear(trans->ctx.net, trans->ctx.chain);
5408                         nft_trans_destroy(trans);
5409                         break;
5410                 case NFT_MSG_NEWRULE:
5411                         trans->ctx.chain->use--;
5412                         list_del_rcu(&nft_trans_rule(trans)->list);
5413                         nft_rule_expr_deactivate(&trans->ctx,
5414                                                  nft_trans_rule(trans),
5415                                                  NFT_TRANS_ABORT);
5416                         break;
5417                 case NFT_MSG_DELRULE:
5418                         trans->ctx.chain->use++;
5419                         nft_clear(trans->ctx.net, nft_trans_rule(trans));
5420                         nft_rule_expr_activate(&trans->ctx, nft_trans_rule(trans));
5421                         nft_trans_destroy(trans);
5422                         break;
5423                 case NFT_MSG_NEWSET:
5424                         trans->ctx.table->use--;
5425                         if (nft_trans_set_bound(trans)) {
5426                                 nft_trans_destroy(trans);
5427                                 break;
5428                         }
5429                         list_del_rcu(&nft_trans_set(trans)->list);
5430                         break;
5431                 case NFT_MSG_DELSET:
5432                         trans->ctx.table->use++;
5433                         nft_clear(trans->ctx.net, nft_trans_set(trans));
5434                         nft_trans_destroy(trans);
5435                         break;
5436                 case NFT_MSG_NEWSETELEM:
5437                         if (nft_trans_elem_set_bound(trans)) {
5438                                 nft_trans_destroy(trans);
5439                                 break;
5440                         }
5441                         te = (struct nft_trans_elem *)trans->data;
5442
5443                         te->set->ops->remove(net, te->set, &te->elem);
5444                         atomic_dec(&te->set->nelems);
5445                         break;
5446                 case NFT_MSG_DELSETELEM:
5447                         te = (struct nft_trans_elem *)trans->data;
5448
5449                         nft_set_elem_activate(net, te->set, &te->elem);
5450                         te->set->ops->activate(net, te->set, &te->elem);
5451                         te->set->ndeact--;
5452
5453                         nft_trans_destroy(trans);
5454                         break;
5455                 case NFT_MSG_NEWOBJ:
5456                         trans->ctx.table->use--;
5457                         list_del_rcu(&nft_trans_obj(trans)->list);
5458                         break;
5459                 case NFT_MSG_DELOBJ:
5460                         trans->ctx.table->use++;
5461                         nft_clear(trans->ctx.net, nft_trans_obj(trans));
5462                         nft_trans_destroy(trans);
5463                         break;
5464                 }
5465         }
5466
5467         synchronize_rcu();
5468
5469         list_for_each_entry_safe_reverse(trans, next,
5470                                          &net->nft.commit_list, list) {
5471                 list_del(&trans->list);
5472                 nf_tables_abort_release(trans);
5473         }
5474
5475         return 0;
5476 }
5477
5478 static bool nf_tables_valid_genid(struct net *net, u32 genid)
5479 {
5480         return net->nft.base_seq == genid;
5481 }
5482
5483 static const struct nfnetlink_subsystem nf_tables_subsys = {
5484         .name           = "nf_tables",
5485         .subsys_id      = NFNL_SUBSYS_NFTABLES,
5486         .cb_count       = NFT_MSG_MAX,
5487         .cb             = nf_tables_cb,
5488         .commit         = nf_tables_commit,
5489         .abort          = nf_tables_abort,
5490         .valid_genid    = nf_tables_valid_genid,
5491 };
5492
5493 int nft_chain_validate_dependency(const struct nft_chain *chain,
5494                                   enum nft_chain_type type)
5495 {
5496         const struct nft_base_chain *basechain;
5497
5498         if (nft_is_base_chain(chain)) {
5499                 basechain = nft_base_chain(chain);
5500                 if (basechain->type->type != type)
5501                         return -EOPNOTSUPP;
5502         }
5503         return 0;
5504 }
5505 EXPORT_SYMBOL_GPL(nft_chain_validate_dependency);
5506
5507 int nft_chain_validate_hooks(const struct nft_chain *chain,
5508                              unsigned int hook_flags)
5509 {
5510         struct nft_base_chain *basechain;
5511
5512         if (nft_is_base_chain(chain)) {
5513                 basechain = nft_base_chain(chain);
5514
5515                 if ((1 << basechain->ops[0].hooknum) & hook_flags)
5516                         return 0;
5517
5518                 return -EOPNOTSUPP;
5519         }
5520
5521         return 0;
5522 }
5523 EXPORT_SYMBOL_GPL(nft_chain_validate_hooks);
5524
5525 /*
5526  * Loop detection - walk through the ruleset beginning at the destination chain
5527  * of a new jump until either the source chain is reached (loop) or all
5528  * reachable chains have been traversed.
5529  *
5530  * The loop check is performed whenever a new jump verdict is added to an
5531  * expression or verdict map or a verdict map is bound to a new chain.
5532  */
5533
5534 static int nf_tables_check_loops(const struct nft_ctx *ctx,
5535                                  const struct nft_chain *chain);
5536
5537 static int nf_tables_loop_check_setelem(const struct nft_ctx *ctx,
5538                                         struct nft_set *set,
5539                                         const struct nft_set_iter *iter,
5540                                         struct nft_set_elem *elem)
5541 {
5542         const struct nft_set_ext *ext = nft_set_elem_ext(set, elem->priv);
5543         const struct nft_data *data;
5544
5545         if (nft_set_ext_exists(ext, NFT_SET_EXT_FLAGS) &&
5546             *nft_set_ext_flags(ext) & NFT_SET_ELEM_INTERVAL_END)
5547                 return 0;
5548
5549         data = nft_set_ext_data(ext);
5550         switch (data->verdict.code) {
5551         case NFT_JUMP:
5552         case NFT_GOTO:
5553                 return nf_tables_check_loops(ctx, data->verdict.chain);
5554         default:
5555                 return 0;
5556         }
5557 }
5558
5559 static int nf_tables_check_loops(const struct nft_ctx *ctx,
5560                                  const struct nft_chain *chain)
5561 {
5562         const struct nft_rule *rule;
5563         const struct nft_expr *expr, *last;
5564         struct nft_set *set;
5565         struct nft_set_binding *binding;
5566         struct nft_set_iter iter;
5567
5568         if (ctx->chain == chain)
5569                 return -ELOOP;
5570
5571         list_for_each_entry(rule, &chain->rules, list) {
5572                 nft_rule_for_each_expr(expr, last, rule) {
5573                         const struct nft_data *data = NULL;
5574                         int err;
5575
5576                         if (!expr->ops->validate)
5577                                 continue;
5578
5579                         err = expr->ops->validate(ctx, expr, &data);
5580                         if (err < 0)
5581                                 return err;
5582
5583                         if (data == NULL)
5584                                 continue;
5585
5586                         switch (data->verdict.code) {
5587                         case NFT_JUMP:
5588                         case NFT_GOTO:
5589                                 err = nf_tables_check_loops(ctx,
5590                                                         data->verdict.chain);
5591                                 if (err < 0)
5592                                         return err;
5593                         default:
5594                                 break;
5595                         }
5596                 }
5597         }
5598
5599         list_for_each_entry(set, &ctx->table->sets, list) {
5600                 if (!nft_is_active_next(ctx->net, set))
5601                         continue;
5602                 if (!(set->flags & NFT_SET_MAP) ||
5603                     set->dtype != NFT_DATA_VERDICT)
5604                         continue;
5605
5606                 list_for_each_entry(binding, &set->bindings, list) {
5607                         if (!(binding->flags & NFT_SET_MAP) ||
5608                             binding->chain != chain)
5609                                 continue;
5610
5611                         iter.genmask    = nft_genmask_next(ctx->net);
5612                         iter.skip       = 0;
5613                         iter.count      = 0;
5614                         iter.err        = 0;
5615                         iter.fn         = nf_tables_loop_check_setelem;
5616
5617                         set->ops->walk(ctx, set, &iter);
5618                         if (iter.err < 0)
5619                                 return iter.err;
5620                 }
5621         }
5622
5623         return 0;
5624 }
5625
5626 /**
5627  *      nft_parse_u32_check - fetch u32 attribute and check for maximum value
5628  *
5629  *      @attr: netlink attribute to fetch value from
5630  *      @max: maximum value to be stored in dest
5631  *      @dest: pointer to the variable
5632  *
5633  *      Parse, check and store a given u32 netlink attribute into variable.
5634  *      This function returns -ERANGE if the value goes over maximum value.
5635  *      Otherwise a 0 is returned and the attribute value is stored in the
5636  *      destination variable.
5637  */
5638 int nft_parse_u32_check(const struct nlattr *attr, int max, u32 *dest)
5639 {
5640         u32 val;
5641
5642         val = ntohl(nla_get_be32(attr));
5643         if (val > max)
5644                 return -ERANGE;
5645
5646         *dest = val;
5647         return 0;
5648 }
5649 EXPORT_SYMBOL_GPL(nft_parse_u32_check);
5650
5651 static int nft_parse_register(const struct nlattr *attr, u32 *preg)
5652 {
5653         unsigned int reg;
5654
5655         reg = ntohl(nla_get_be32(attr));
5656         switch (reg) {
5657         case NFT_REG_VERDICT...NFT_REG_4:
5658                 *preg = reg * NFT_REG_SIZE / NFT_REG32_SIZE;
5659                 break;
5660         case NFT_REG32_00...NFT_REG32_15:
5661                 *preg = reg + NFT_REG_SIZE / NFT_REG32_SIZE - NFT_REG32_00;
5662                 break;
5663         default:
5664                 return -ERANGE;
5665         }
5666
5667         return 0;
5668 }
5669
5670 /**
5671  *      nft_dump_register - dump a register value to a netlink attribute
5672  *
5673  *      @skb: socket buffer
5674  *      @attr: attribute number
5675  *      @reg: register number
5676  *
5677  *      Construct a netlink attribute containing the register number. For
5678  *      compatibility reasons, register numbers being a multiple of 4 are
5679  *      translated to the corresponding 128 bit register numbers.
5680  */
5681 int nft_dump_register(struct sk_buff *skb, unsigned int attr, unsigned int reg)
5682 {
5683         if (reg % (NFT_REG_SIZE / NFT_REG32_SIZE) == 0)
5684                 reg = reg / (NFT_REG_SIZE / NFT_REG32_SIZE);
5685         else
5686                 reg = reg - NFT_REG_SIZE / NFT_REG32_SIZE + NFT_REG32_00;
5687
5688         return nla_put_be32(skb, attr, htonl(reg));
5689 }
5690 EXPORT_SYMBOL_GPL(nft_dump_register);
5691
5692 /**
5693  *      nft_validate_register_load - validate a load from a register
5694  *
5695  *      @reg: the register number
5696  *      @len: the length of the data
5697  *
5698  *      Validate that the input register is one of the general purpose
5699  *      registers and that the length of the load is within the bounds.
5700  */
5701 static int nft_validate_register_load(enum nft_registers reg, unsigned int len)
5702 {
5703         if (reg < NFT_REG_1 * NFT_REG_SIZE / NFT_REG32_SIZE)
5704                 return -EINVAL;
5705         if (len == 0)
5706                 return -EINVAL;
5707         if (reg * NFT_REG32_SIZE + len > FIELD_SIZEOF(struct nft_regs, data))
5708                 return -ERANGE;
5709
5710         return 0;
5711 }
5712
5713 int nft_parse_register_load(const struct nlattr *attr, u8 *sreg, u32 len)
5714 {
5715         u32 reg;
5716         int err;
5717
5718         err = nft_parse_register(attr, &reg);
5719         if (err < 0)
5720                 return err;
5721
5722         err = nft_validate_register_load(reg, len);
5723         if (err < 0)
5724                 return err;
5725
5726         *sreg = reg;
5727         return 0;
5728 }
5729 EXPORT_SYMBOL_GPL(nft_parse_register_load);
5730
5731 /**
5732  *      nft_validate_register_store - validate an expressions' register store
5733  *
5734  *      @ctx: context of the expression performing the load
5735  *      @reg: the destination register number
5736  *      @data: the data to load
5737  *      @type: the data type
5738  *      @len: the length of the data
5739  *
5740  *      Validate that a data load uses the appropriate data type for
5741  *      the destination register and the length is within the bounds.
5742  *      A value of NULL for the data means that its runtime gathered
5743  *      data.
5744  */
5745 static int nft_validate_register_store(const struct nft_ctx *ctx,
5746                                        enum nft_registers reg,
5747                                        const struct nft_data *data,
5748                                        enum nft_data_types type,
5749                                        unsigned int len)
5750 {
5751         int err;
5752
5753         switch (reg) {
5754         case NFT_REG_VERDICT:
5755                 if (type != NFT_DATA_VERDICT)
5756                         return -EINVAL;
5757
5758                 if (data != NULL &&
5759                     (data->verdict.code == NFT_GOTO ||
5760                      data->verdict.code == NFT_JUMP)) {
5761                         err = nf_tables_check_loops(ctx, data->verdict.chain);
5762                         if (err < 0)
5763                                 return err;
5764
5765                         if (ctx->chain->level + 1 >
5766                             data->verdict.chain->level) {
5767                                 if (ctx->chain->level + 1 == NFT_JUMP_STACK_SIZE)
5768                                         return -EMLINK;
5769                                 data->verdict.chain->level = ctx->chain->level + 1;
5770                         }
5771                 }
5772
5773                 return 0;
5774         default:
5775                 if (reg < NFT_REG_1 * NFT_REG_SIZE / NFT_REG32_SIZE)
5776                         return -EINVAL;
5777                 if (len == 0)
5778                         return -EINVAL;
5779                 if (reg * NFT_REG32_SIZE + len >
5780                     FIELD_SIZEOF(struct nft_regs, data))
5781                         return -ERANGE;
5782
5783                 if (data != NULL && type != NFT_DATA_VALUE)
5784                         return -EINVAL;
5785                 return 0;
5786         }
5787 }
5788
5789 int nft_parse_register_store(const struct nft_ctx *ctx,
5790                              const struct nlattr *attr, u8 *dreg,
5791                              const struct nft_data *data,
5792                              enum nft_data_types type, unsigned int len)
5793 {
5794         int err;
5795         u32 reg;
5796
5797         err = nft_parse_register(attr, &reg);
5798         if (err < 0)
5799                 return err;
5800
5801         err = nft_validate_register_store(ctx, reg, data, type, len);
5802         if (err < 0)
5803                 return err;
5804
5805         *dreg = reg;
5806         return 0;
5807 }
5808 EXPORT_SYMBOL_GPL(nft_parse_register_store);
5809
5810 static const struct nla_policy nft_verdict_policy[NFTA_VERDICT_MAX + 1] = {
5811         [NFTA_VERDICT_CODE]     = { .type = NLA_U32 },
5812         [NFTA_VERDICT_CHAIN]    = { .type = NLA_STRING,
5813                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
5814 };
5815
5816 static int nft_verdict_init(const struct nft_ctx *ctx, struct nft_data *data,
5817                             struct nft_data_desc *desc, const struct nlattr *nla)
5818 {
5819         u8 genmask = nft_genmask_next(ctx->net);
5820         struct nlattr *tb[NFTA_VERDICT_MAX + 1];
5821         struct nft_chain *chain;
5822         int err;
5823
5824         err = nla_parse_nested(tb, NFTA_VERDICT_MAX, nla, nft_verdict_policy,
5825                                NULL);
5826         if (err < 0)
5827                 return err;
5828
5829         if (!tb[NFTA_VERDICT_CODE])
5830                 return -EINVAL;
5831         data->verdict.code = ntohl(nla_get_be32(tb[NFTA_VERDICT_CODE]));
5832
5833         switch (data->verdict.code) {
5834         default:
5835                 switch (data->verdict.code & NF_VERDICT_MASK) {
5836                 case NF_ACCEPT:
5837                 case NF_DROP:
5838                 case NF_QUEUE:
5839                         break;
5840                 default:
5841                         return -EINVAL;
5842                 }
5843                 /* fall through */
5844         case NFT_CONTINUE:
5845         case NFT_BREAK:
5846         case NFT_RETURN:
5847                 break;
5848         case NFT_JUMP:
5849         case NFT_GOTO:
5850                 if (!tb[NFTA_VERDICT_CHAIN])
5851                         return -EINVAL;
5852                 chain = nf_tables_chain_lookup(ctx->table,
5853                                                tb[NFTA_VERDICT_CHAIN], genmask);
5854                 if (IS_ERR(chain))
5855                         return PTR_ERR(chain);
5856                 if (nft_is_base_chain(chain))
5857                         return -EOPNOTSUPP;
5858
5859                 chain->use++;
5860                 data->verdict.chain = chain;
5861                 break;
5862         }
5863
5864         desc->len = sizeof(data->verdict);
5865         desc->type = NFT_DATA_VERDICT;
5866         return 0;
5867 }
5868
5869 static void nft_verdict_uninit(const struct nft_data *data)
5870 {
5871         switch (data->verdict.code) {
5872         case NFT_JUMP:
5873         case NFT_GOTO:
5874                 data->verdict.chain->use--;
5875                 break;
5876         }
5877 }
5878
5879 int nft_verdict_dump(struct sk_buff *skb, int type, const struct nft_verdict *v)
5880 {
5881         struct nlattr *nest;
5882
5883         nest = nla_nest_start(skb, type);
5884         if (!nest)
5885                 goto nla_put_failure;
5886
5887         if (nla_put_be32(skb, NFTA_VERDICT_CODE, htonl(v->code)))
5888                 goto nla_put_failure;
5889
5890         switch (v->code) {
5891         case NFT_JUMP:
5892         case NFT_GOTO:
5893                 if (nla_put_string(skb, NFTA_VERDICT_CHAIN,
5894                                    v->chain->name))
5895                         goto nla_put_failure;
5896         }
5897         nla_nest_end(skb, nest);
5898         return 0;
5899
5900 nla_put_failure:
5901         return -1;
5902 }
5903
5904 static int nft_value_init(const struct nft_ctx *ctx,
5905                           struct nft_data *data, unsigned int size,
5906                           struct nft_data_desc *desc, const struct nlattr *nla)
5907 {
5908         unsigned int len;
5909
5910         len = nla_len(nla);
5911         if (len == 0)
5912                 return -EINVAL;
5913         if (len > size)
5914                 return -EOVERFLOW;
5915
5916         nla_memcpy(data->data, nla, len);
5917         desc->type = NFT_DATA_VALUE;
5918         desc->len  = len;
5919         return 0;
5920 }
5921
5922 static int nft_value_dump(struct sk_buff *skb, const struct nft_data *data,
5923                           unsigned int len)
5924 {
5925         return nla_put(skb, NFTA_DATA_VALUE, len, data->data);
5926 }
5927
5928 static const struct nla_policy nft_data_policy[NFTA_DATA_MAX + 1] = {
5929         [NFTA_DATA_VALUE]       = { .type = NLA_BINARY },
5930         [NFTA_DATA_VERDICT]     = { .type = NLA_NESTED },
5931 };
5932
5933 /**
5934  *      nft_data_init - parse nf_tables data netlink attributes
5935  *
5936  *      @ctx: context of the expression using the data
5937  *      @data: destination struct nft_data
5938  *      @size: maximum data length
5939  *      @desc: data description
5940  *      @nla: netlink attribute containing data
5941  *
5942  *      Parse the netlink data attributes and initialize a struct nft_data.
5943  *      The type and length of data are returned in the data description.
5944  *
5945  *      The caller can indicate that it only wants to accept data of type
5946  *      NFT_DATA_VALUE by passing NULL for the ctx argument.
5947  */
5948 int nft_data_init(const struct nft_ctx *ctx,
5949                   struct nft_data *data, unsigned int size,
5950                   struct nft_data_desc *desc, const struct nlattr *nla)
5951 {
5952         struct nlattr *tb[NFTA_DATA_MAX + 1];
5953         int err;
5954
5955         err = nla_parse_nested(tb, NFTA_DATA_MAX, nla, nft_data_policy, NULL);
5956         if (err < 0)
5957                 return err;
5958
5959         if (tb[NFTA_DATA_VALUE])
5960                 return nft_value_init(ctx, data, size, desc,
5961                                       tb[NFTA_DATA_VALUE]);
5962         if (tb[NFTA_DATA_VERDICT] && ctx != NULL)
5963                 return nft_verdict_init(ctx, data, desc, tb[NFTA_DATA_VERDICT]);
5964         return -EINVAL;
5965 }
5966 EXPORT_SYMBOL_GPL(nft_data_init);
5967
5968 /**
5969  *      nft_data_release - release a nft_data item
5970  *
5971  *      @data: struct nft_data to release
5972  *      @type: type of data
5973  *
5974  *      Release a nft_data item. NFT_DATA_VALUE types can be silently discarded,
5975  *      all others need to be released by calling this function.
5976  */
5977 void nft_data_release(const struct nft_data *data, enum nft_data_types type)
5978 {
5979         if (type < NFT_DATA_VERDICT)
5980                 return;
5981         switch (type) {
5982         case NFT_DATA_VERDICT:
5983                 return nft_verdict_uninit(data);
5984         default:
5985                 WARN_ON(1);
5986         }
5987 }
5988 EXPORT_SYMBOL_GPL(nft_data_release);
5989
5990 int nft_data_dump(struct sk_buff *skb, int attr, const struct nft_data *data,
5991                   enum nft_data_types type, unsigned int len)
5992 {
5993         struct nlattr *nest;
5994         int err;
5995
5996         nest = nla_nest_start(skb, attr);
5997         if (nest == NULL)
5998                 return -1;
5999
6000         switch (type) {
6001         case NFT_DATA_VALUE:
6002                 err = nft_value_dump(skb, data, len);
6003                 break;
6004         case NFT_DATA_VERDICT:
6005                 err = nft_verdict_dump(skb, NFTA_DATA_VERDICT, &data->verdict);
6006                 break;
6007         default:
6008                 err = -EINVAL;
6009                 WARN_ON(1);
6010         }
6011
6012         nla_nest_end(skb, nest);
6013         return err;
6014 }
6015 EXPORT_SYMBOL_GPL(nft_data_dump);
6016
6017 static int __net_init nf_tables_init_net(struct net *net)
6018 {
6019         INIT_LIST_HEAD(&net->nft.af_info);
6020         INIT_LIST_HEAD(&net->nft.commit_list);
6021         net->nft.base_seq = 1;
6022         return 0;
6023 }
6024
6025 int __nft_release_basechain(struct nft_ctx *ctx)
6026 {
6027         struct nft_rule *rule, *nr;
6028
6029         BUG_ON(!nft_is_base_chain(ctx->chain));
6030
6031         nf_tables_unregister_hooks(ctx->net, ctx->chain->table, ctx->chain,
6032                                    ctx->afi->nops);
6033         list_for_each_entry_safe(rule, nr, &ctx->chain->rules, list) {
6034                 list_del(&rule->list);
6035                 ctx->chain->use--;
6036                 nf_tables_rule_release(ctx, rule);
6037         }
6038         list_del(&ctx->chain->list);
6039         ctx->table->use--;
6040         nf_tables_chain_destroy(ctx->chain);
6041
6042         return 0;
6043 }
6044 EXPORT_SYMBOL_GPL(__nft_release_basechain);
6045
6046 /* Called by nft_unregister_afinfo() from __net_exit path, nfnl_lock is held. */
6047 static void __nft_release_afinfo(struct net *net, struct nft_af_info *afi)
6048 {
6049         struct nft_table *table, *nt;
6050         struct nft_chain *chain, *nc;
6051         struct nft_object *obj, *ne;
6052         struct nft_rule *rule, *nr;
6053         struct nft_set *set, *ns;
6054         struct nft_ctx ctx = {
6055                 .net    = net,
6056                 .afi    = afi,
6057         };
6058
6059         list_for_each_entry_safe(table, nt, &afi->tables, list) {
6060                 list_for_each_entry(chain, &table->chains, list)
6061                         nf_tables_unregister_hooks(net, table, chain,
6062                                                    afi->nops);
6063                 /* No packets are walking on these chains anymore. */
6064                 ctx.table = table;
6065                 list_for_each_entry(chain, &table->chains, list) {
6066                         ctx.chain = chain;
6067                         list_for_each_entry_safe(rule, nr, &chain->rules, list) {
6068                                 list_del(&rule->list);
6069                                 chain->use--;
6070                                 nf_tables_rule_release(&ctx, rule);
6071                         }
6072                 }
6073                 list_for_each_entry_safe(set, ns, &table->sets, list) {
6074                         list_del(&set->list);
6075                         table->use--;
6076                         nft_set_destroy(set);
6077                 }
6078                 list_for_each_entry_safe(obj, ne, &table->objects, list) {
6079                         list_del(&obj->list);
6080                         table->use--;
6081                         nft_obj_destroy(obj);
6082                 }
6083                 list_for_each_entry_safe(chain, nc, &table->chains, list) {
6084                         list_del(&chain->list);
6085                         table->use--;
6086                         nf_tables_chain_destroy(chain);
6087                 }
6088                 list_del(&table->list);
6089                 nf_tables_table_destroy(&ctx);
6090         }
6091 }
6092
6093 static struct pernet_operations nf_tables_net_ops = {
6094         .init   = nf_tables_init_net,
6095 };
6096
6097 static int __init nf_tables_module_init(void)
6098 {
6099         int err;
6100
6101         info = kmalloc(sizeof(struct nft_expr_info) * NFT_RULE_MAXEXPRS,
6102                        GFP_KERNEL);
6103         if (info == NULL) {
6104                 err = -ENOMEM;
6105                 goto err1;
6106         }
6107
6108         err = nf_tables_core_module_init();
6109         if (err < 0)
6110                 goto err2;
6111
6112         err = nfnetlink_subsys_register(&nf_tables_subsys);
6113         if (err < 0)
6114                 goto err3;
6115
6116         pr_info("nf_tables: (c) 2007-2009 Patrick McHardy <kaber@trash.net>\n");
6117         return register_pernet_subsys(&nf_tables_net_ops);
6118 err3:
6119         nf_tables_core_module_exit();
6120 err2:
6121         kfree(info);
6122 err1:
6123         return err;
6124 }
6125
6126 static void __exit nf_tables_module_exit(void)
6127 {
6128         unregister_pernet_subsys(&nf_tables_net_ops);
6129         nfnetlink_subsys_unregister(&nf_tables_subsys);
6130         rcu_barrier();
6131         nf_tables_core_module_exit();
6132         kfree(info);
6133 }
6134
6135 module_init(nf_tables_module_init);
6136 module_exit(nf_tables_module_exit);
6137
6138 MODULE_LICENSE("GPL");
6139 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
6140 MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_NFTABLES);