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