net/netfilter/nf_tables_api.c

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