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