net/netfilter/nf_tables_api.c

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