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