net/netfilter/nf_tables_api.c

   1 /*
   2  * Copyright (c) 2007-2009 Patrick McHardy <kaber@trash.net>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * Development of this code funded by Astaro AG (http://www.astaro.com/)
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 #include <linux/list.h>
  14 #include <linux/skbuff.h>
  15 #include <linux/netlink.h>
  16 #include <linux/netfilter.h>
  17 #include <linux/netfilter/nfnetlink.h>
  18 #include <linux/netfilter/nf_tables.h>
  19 #include <net/netfilter/nf_tables_core.h>
  20 #include <net/netfilter/nf_tables.h>
  21 #include <net/net_namespace.h>
  22 #include <net/sock.h>
  23
  24 static LIST_HEAD(nf_tables_expressions);
  25
  26 /**
  27  *      nft_register_afinfo - register nf_tables address family info
  28  *
  29  *      @afi: address family info to register
  30  *
  31  *      Register the address family for use with nf_tables. Returns zero on
  32  *      success or a negative errno code otherwise.
  33  */
  34 int nft_register_afinfo(struct net *net, struct nft_af_info *afi)
  35 {
  36         INIT_LIST_HEAD(&afi->tables);
  37         nfnl_lock(NFNL_SUBSYS_NFTABLES);
  38         list_add_tail(&afi->list, &net->nft.af_info);
  39         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
  40         return 0;
  41 }
  42 EXPORT_SYMBOL_GPL(nft_register_afinfo);
  43
  44 /**
  45  *      nft_unregister_afinfo - unregister nf_tables address family info
  46  *
  47  *      @afi: address family info to unregister
  48  *
  49  *      Unregister the address family for use with nf_tables.
  50  */
  51 void nft_unregister_afinfo(struct nft_af_info *afi)
  52 {
  53         nfnl_lock(NFNL_SUBSYS_NFTABLES);
  54         list_del(&afi->list);
  55         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
  56 }
  57 EXPORT_SYMBOL_GPL(nft_unregister_afinfo);
  58
  59 static struct nft_af_info *nft_afinfo_lookup(struct net *net, int family)
  60 {
  61         struct nft_af_info *afi;
  62
  63         list_for_each_entry(afi, &net->nft.af_info, list) {
  64                 if (afi->family == family)
  65                         return afi;
  66         }
  67         return NULL;
  68 }
  69
  70 static struct nft_af_info *
  71 nf_tables_afinfo_lookup(struct net *net, int family, bool autoload)
  72 {
  73         struct nft_af_info *afi;
  74
  75         afi = nft_afinfo_lookup(net, family);
  76         if (afi != NULL)
  77                 return afi;
  78 #ifdef CONFIG_MODULES
  79         if (autoload) {
  80                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
  81                 request_module("nft-afinfo-%u", family);
  82                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
  83                 afi = nft_afinfo_lookup(net, family);
  84                 if (afi != NULL)
  85                         return ERR_PTR(-EAGAIN);
  86         }
  87 #endif
  88         return ERR_PTR(-EAFNOSUPPORT);
  89 }
  90
  91 /*
  92  * Tables
  93  */
  94
  95 static struct nft_table *nft_table_lookup(const struct nft_af_info *afi,
  96                                           const struct nlattr *nla)
  97 {
  98         struct nft_table *table;
  99
 100         list_for_each_entry(table, &afi->tables, list) {
 101                 if (!nla_strcmp(nla, table->name))
 102                         return table;
 103         }
 104         return NULL;
 105 }
 106
 107 static struct nft_table *nf_tables_table_lookup(const struct nft_af_info *afi,
 108                                                 const struct nlattr *nla)
 109 {
 110         struct nft_table *table;
 111
 112         if (nla == NULL)
 113                 return ERR_PTR(-EINVAL);
 114
 115         table = nft_table_lookup(afi, nla);
 116         if (table != NULL)
 117                 return table;
 118
 119         return ERR_PTR(-ENOENT);
 120 }
 121
 122 static inline u64 nf_tables_alloc_handle(struct nft_table *table)
 123 {
 124         return ++table->hgenerator;
 125 }
 126
 127 static struct nf_chain_type *chain_type[AF_MAX][NFT_CHAIN_T_MAX];
 128
 129 static int __nf_tables_chain_type_lookup(int family, const struct nlattr *nla)
 130 {
 131         int i;
 132
 133         for (i=0; i<NFT_CHAIN_T_MAX; i++) {
 134                 if (chain_type[family][i] != NULL &&
 135                     !nla_strcmp(nla, chain_type[family][i]->name))
 136                         return i;
 137         }
 138         return -1;
 139 }
 140
 141 static int nf_tables_chain_type_lookup(const struct nft_af_info *afi,
 142                                        const struct nlattr *nla,
 143                                        bool autoload)
 144 {
 145         int type;
 146
 147         type = __nf_tables_chain_type_lookup(afi->family, nla);
 148 #ifdef CONFIG_MODULES
 149         if (type < 0 && autoload) {
 150                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
 151                 request_module("nft-chain-%u-%*.s", afi->family,
 152                                nla_len(nla)-1, (const char *)nla_data(nla));
 153                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
 154                 type = __nf_tables_chain_type_lookup(afi->family, nla);
 155         }
 156 #endif
 157         return type;
 158 }
 159
 160 static const struct nla_policy nft_table_policy[NFTA_TABLE_MAX + 1] = {
 161         [NFTA_TABLE_NAME]       = { .type = NLA_STRING },
 162         [NFTA_TABLE_FLAGS]      = { .type = NLA_U32 },
 163 };
 164
 165 static int nf_tables_fill_table_info(struct sk_buff *skb, u32 portid, u32 seq,
 166                                      int event, u32 flags, int family,
 167                                      const struct nft_table *table)
 168 {
 169         struct nlmsghdr *nlh;
 170         struct nfgenmsg *nfmsg;
 171
 172         event |= NFNL_SUBSYS_NFTABLES << 8;
 173         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags);
 174         if (nlh == NULL)
 175                 goto nla_put_failure;
 176
 177         nfmsg = nlmsg_data(nlh);
 178         nfmsg->nfgen_family     = family;
 179         nfmsg->version          = NFNETLINK_V0;
 180         nfmsg->res_id           = 0;
 181
 182         if (nla_put_string(skb, NFTA_TABLE_NAME, table->name) ||
 183             nla_put_be32(skb, NFTA_TABLE_FLAGS, htonl(table->flags)))
 184                 goto nla_put_failure;
 185
 186         return nlmsg_end(skb, nlh);
 187
 188 nla_put_failure:
 189         nlmsg_trim(skb, nlh);
 190         return -1;
 191 }
 192
 193 static int nf_tables_table_notify(const struct sk_buff *oskb,
 194                                   const struct nlmsghdr *nlh,
 195                                   const struct nft_table *table,
 196                                   int event, int family)
 197 {
 198         struct sk_buff *skb;
 199         u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
 200         u32 seq = nlh ? nlh->nlmsg_seq : 0;
 201         struct net *net = oskb ? sock_net(oskb->sk) : &init_net;
 202         bool report;
 203         int err;
 204
 205         report = nlh ? nlmsg_report(nlh) : false;
 206         if (!report && !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
 207                 return 0;
 208
 209         err = -ENOBUFS;
 210         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 211         if (skb == NULL)
 212                 goto err;
 213
 214         err = nf_tables_fill_table_info(skb, portid, seq, event, 0,
 215                                         family, table);
 216         if (err < 0) {
 217                 kfree_skb(skb);
 218                 goto err;
 219         }
 220
 221         err = nfnetlink_send(skb, net, portid, NFNLGRP_NFTABLES, report,
 222                              GFP_KERNEL);
 223 err:
 224         if (err < 0)
 225                 nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, err);
 226         return err;
 227 }
 228
 229 static int nf_tables_dump_tables(struct sk_buff *skb,
 230                                  struct netlink_callback *cb)
 231 {
 232         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
 233         const struct nft_af_info *afi;
 234         const struct nft_table *table;
 235         unsigned int idx = 0, s_idx = cb->args[0];
 236         struct net *net = sock_net(skb->sk);
 237         int family = nfmsg->nfgen_family;
 238
 239         list_for_each_entry(afi, &net->nft.af_info, list) {
 240                 if (family != NFPROTO_UNSPEC && family != afi->family)
 241                         continue;
 242
 243                 list_for_each_entry(table, &afi->tables, list) {
 244                         if (idx < s_idx)
 245                                 goto cont;
 246                         if (idx > s_idx)
 247                                 memset(&cb->args[1], 0,
 248                                        sizeof(cb->args) - sizeof(cb->args[0]));
 249                         if (nf_tables_fill_table_info(skb,
 250                                                       NETLINK_CB(cb->skb).portid,
 251                                                       cb->nlh->nlmsg_seq,
 252                                                       NFT_MSG_NEWTABLE,
 253                                                       NLM_F_MULTI,
 254                                                       afi->family, table) < 0)
 255                                 goto done;
 256 cont:
 257                         idx++;
 258                 }
 259         }
 260 done:
 261         cb->args[0] = idx;
 262         return skb->len;
 263 }
 264
 265 static int nf_tables_gettable(struct sock *nlsk, struct sk_buff *skb,
 266                               const struct nlmsghdr *nlh,
 267                               const struct nlattr * const nla[])
 268 {
 269         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
 270         const struct nft_af_info *afi;
 271         const struct nft_table *table;
 272         struct sk_buff *skb2;
 273         struct net *net = sock_net(skb->sk);
 274         int family = nfmsg->nfgen_family;
 275         int err;
 276
 277         if (nlh->nlmsg_flags & NLM_F_DUMP) {
 278                 struct netlink_dump_control c = {
 279                         .dump = nf_tables_dump_tables,
 280                 };
 281                 return netlink_dump_start(nlsk, skb, nlh, &c);
 282         }
 283
 284         afi = nf_tables_afinfo_lookup(net, family, false);
 285         if (IS_ERR(afi))
 286                 return PTR_ERR(afi);
 287
 288         table = nf_tables_table_lookup(afi, nla[NFTA_TABLE_NAME]);
 289         if (IS_ERR(table))
 290                 return PTR_ERR(table);
 291
 292         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
 293         if (!skb2)
 294                 return -ENOMEM;
 295
 296         err = nf_tables_fill_table_info(skb2, NETLINK_CB(skb).portid,
 297                                         nlh->nlmsg_seq, NFT_MSG_NEWTABLE, 0,
 298                                         family, table);
 299         if (err < 0)
 300                 goto err;
 301
 302         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
 303
 304 err:
 305         kfree_skb(skb2);
 306         return err;
 307 }
 308
 309 static int nf_tables_table_enable(struct nft_table *table)
 310 {
 311         struct nft_chain *chain;
 312         int err, i = 0;
 313
 314         list_for_each_entry(chain, &table->chains, list) {
 315                 err = nf_register_hook(&nft_base_chain(chain)->ops);
 316                 if (err < 0)
 317                         goto err;
 318
 319                 i++;
 320         }
 321         return 0;
 322 err:
 323         list_for_each_entry(chain, &table->chains, list) {
 324                 if (i-- <= 0)
 325                         break;
 326
 327                 nf_unregister_hook(&nft_base_chain(chain)->ops);
 328         }
 329         return err;
 330 }
 331
 332 static int nf_tables_table_disable(struct nft_table *table)
 333 {
 334         struct nft_chain *chain;
 335
 336         list_for_each_entry(chain, &table->chains, list)
 337                 nf_unregister_hook(&nft_base_chain(chain)->ops);
 338
 339         return 0;
 340 }
 341
 342 static int nf_tables_updtable(struct sock *nlsk, struct sk_buff *skb,
 343                               const struct nlmsghdr *nlh,
 344                               const struct nlattr * const nla[],
 345                               struct nft_af_info *afi, struct nft_table *table)
 346 {
 347         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
 348         int family = nfmsg->nfgen_family, ret = 0;
 349
 350         if (nla[NFTA_TABLE_FLAGS]) {
 351                 __be32 flags;
 352
 353                 flags = ntohl(nla_get_be32(nla[NFTA_TABLE_FLAGS]));
 354                 if (flags & ~NFT_TABLE_F_DORMANT)
 355                         return -EINVAL;
 356
 357                 if ((flags & NFT_TABLE_F_DORMANT) &&
 358                     !(table->flags & NFT_TABLE_F_DORMANT)) {
 359                         ret = nf_tables_table_disable(table);
 360                         if (ret >= 0)
 361                                 table->flags |= NFT_TABLE_F_DORMANT;
 362                 } else if (!(flags & NFT_TABLE_F_DORMANT) &&
 363                            table->flags & NFT_TABLE_F_DORMANT) {
 364                         ret = nf_tables_table_enable(table);
 365                         if (ret >= 0)
 366                                 table->flags &= ~NFT_TABLE_F_DORMANT;
 367                 }
 368                 if (ret < 0)
 369                         goto err;
 370         }
 371
 372         nf_tables_table_notify(skb, nlh, table, NFT_MSG_NEWTABLE, family);
 373 err:
 374         return ret;
 375 }
 376
 377 static int nf_tables_newtable(struct sock *nlsk, struct sk_buff *skb,
 378                               const struct nlmsghdr *nlh,
 379                               const struct nlattr * const nla[])
 380 {
 381         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
 382         const struct nlattr *name;
 383         struct nft_af_info *afi;
 384         struct nft_table *table;
 385         struct net *net = sock_net(skb->sk);
 386         int family = nfmsg->nfgen_family;
 387
 388         afi = nf_tables_afinfo_lookup(net, family, true);
 389         if (IS_ERR(afi))
 390                 return PTR_ERR(afi);
 391
 392         name = nla[NFTA_TABLE_NAME];
 393         table = nf_tables_table_lookup(afi, name);
 394         if (IS_ERR(table)) {
 395                 if (PTR_ERR(table) != -ENOENT)
 396                         return PTR_ERR(table);
 397                 table = NULL;
 398         }
 399
 400         if (table != NULL) {
 401                 if (nlh->nlmsg_flags & NLM_F_EXCL)
 402                         return -EEXIST;
 403                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
 404                         return -EOPNOTSUPP;
 405                 return nf_tables_updtable(nlsk, skb, nlh, nla, afi, table);
 406         }
 407
 408         table = kzalloc(sizeof(*table) + nla_len(name), GFP_KERNEL);
 409         if (table == NULL)
 410                 return -ENOMEM;
 411
 412         nla_strlcpy(table->name, name, nla_len(name));
 413         INIT_LIST_HEAD(&table->chains);
 414         INIT_LIST_HEAD(&table->sets);
 415
 416         if (nla[NFTA_TABLE_FLAGS]) {
 417                 __be32 flags;
 418
 419                 flags = ntohl(nla_get_be32(nla[NFTA_TABLE_FLAGS]));
 420                 if (flags & ~NFT_TABLE_F_DORMANT) {
 421                         kfree(table);
 422                         return -EINVAL;
 423                 }
 424
 425                 table->flags |= flags;
 426         }
 427
 428         list_add_tail(&table->list, &afi->tables);
 429         nf_tables_table_notify(skb, nlh, table, NFT_MSG_NEWTABLE, family);
 430         return 0;
 431 }
 432
 433 static int nf_tables_deltable(struct sock *nlsk, struct sk_buff *skb,
 434                               const struct nlmsghdr *nlh,
 435                               const struct nlattr * const nla[])
 436 {
 437         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
 438         struct nft_af_info *afi;
 439         struct nft_table *table;
 440         struct net *net = sock_net(skb->sk);
 441         int family = nfmsg->nfgen_family;
 442
 443         afi = nf_tables_afinfo_lookup(net, family, false);
 444         if (IS_ERR(afi))
 445                 return PTR_ERR(afi);
 446
 447         table = nf_tables_table_lookup(afi, nla[NFTA_TABLE_NAME]);
 448         if (IS_ERR(table))
 449                 return PTR_ERR(table);
 450
 451         if (table->use)
 452                 return -EBUSY;
 453
 454         list_del(&table->list);
 455         nf_tables_table_notify(skb, nlh, table, NFT_MSG_DELTABLE, family);
 456         kfree(table);
 457         return 0;
 458 }
 459
 460 int nft_register_chain_type(struct nf_chain_type *ctype)
 461 {
 462         int err = 0;
 463
 464         nfnl_lock(NFNL_SUBSYS_NFTABLES);
 465         if (chain_type[ctype->family][ctype->type] != NULL) {
 466                 err = -EBUSY;
 467                 goto out;
 468         }
 469
 470         if (!try_module_get(ctype->me))
 471                 goto out;
 472
 473         chain_type[ctype->family][ctype->type] = ctype;
 474 out:
 475         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
 476         return err;
 477 }
 478 EXPORT_SYMBOL_GPL(nft_register_chain_type);
 479
 480 void nft_unregister_chain_type(struct nf_chain_type *ctype)
 481 {
 482         nfnl_lock(NFNL_SUBSYS_NFTABLES);
 483         chain_type[ctype->family][ctype->type] = NULL;
 484         module_put(ctype->me);
 485         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
 486 }
 487 EXPORT_SYMBOL_GPL(nft_unregister_chain_type);
 488
 489 /*
 490  * Chains
 491  */
 492
 493 static struct nft_chain *
 494 nf_tables_chain_lookup_byhandle(const struct nft_table *table, u64 handle)
 495 {
 496         struct nft_chain *chain;
 497
 498         list_for_each_entry(chain, &table->chains, list) {
 499                 if (chain->handle == handle)
 500                         return chain;
 501         }
 502
 503         return ERR_PTR(-ENOENT);
 504 }
 505
 506 static struct nft_chain *nf_tables_chain_lookup(const struct nft_table *table,
 507                                                 const struct nlattr *nla)
 508 {
 509         struct nft_chain *chain;
 510
 511         if (nla == NULL)
 512                 return ERR_PTR(-EINVAL);
 513
 514         list_for_each_entry(chain, &table->chains, list) {
 515                 if (!nla_strcmp(nla, chain->name))
 516                         return chain;
 517         }
 518
 519         return ERR_PTR(-ENOENT);
 520 }
 521
 522 static const struct nla_policy nft_chain_policy[NFTA_CHAIN_MAX + 1] = {
 523         [NFTA_CHAIN_TABLE]      = { .type = NLA_STRING },
 524         [NFTA_CHAIN_HANDLE]     = { .type = NLA_U64 },
 525         [NFTA_CHAIN_NAME]       = { .type = NLA_STRING,
 526                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
 527         [NFTA_CHAIN_HOOK]       = { .type = NLA_NESTED },
 528         [NFTA_CHAIN_POLICY]     = { .type = NLA_U32 },
 529         [NFTA_CHAIN_TYPE]       = { .type = NLA_NUL_STRING },
 530         [NFTA_CHAIN_COUNTERS]   = { .type = NLA_NESTED },
 531 };
 532
 533 static const struct nla_policy nft_hook_policy[NFTA_HOOK_MAX + 1] = {
 534         [NFTA_HOOK_HOOKNUM]     = { .type = NLA_U32 },
 535         [NFTA_HOOK_PRIORITY]    = { .type = NLA_U32 },
 536 };
 537
 538 static int nft_dump_stats(struct sk_buff *skb, struct nft_stats __percpu *stats)
 539 {
 540         struct nft_stats *cpu_stats, total;
 541         struct nlattr *nest;
 542         int cpu;
 543
 544         memset(&total, 0, sizeof(total));
 545         for_each_possible_cpu(cpu) {
 546                 cpu_stats = per_cpu_ptr(stats, cpu);
 547                 total.pkts += cpu_stats->pkts;
 548                 total.bytes += cpu_stats->bytes;
 549         }
 550         nest = nla_nest_start(skb, NFTA_CHAIN_COUNTERS);
 551         if (nest == NULL)
 552                 goto nla_put_failure;
 553
 554         if (nla_put_be64(skb, NFTA_COUNTER_PACKETS, cpu_to_be64(total.pkts)) ||
 555             nla_put_be64(skb, NFTA_COUNTER_BYTES, cpu_to_be64(total.bytes)))
 556                 goto nla_put_failure;
 557
 558         nla_nest_end(skb, nest);
 559         return 0;
 560
 561 nla_put_failure:
 562         return -ENOSPC;
 563 }
 564
 565 static int nf_tables_fill_chain_info(struct sk_buff *skb, u32 portid, u32 seq,
 566                                      int event, u32 flags, int family,
 567                                      const struct nft_table *table,
 568                                      const struct nft_chain *chain)
 569 {
 570         struct nlmsghdr *nlh;
 571         struct nfgenmsg *nfmsg;
 572
 573         event |= NFNL_SUBSYS_NFTABLES << 8;
 574         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg), flags);
 575         if (nlh == NULL)
 576                 goto nla_put_failure;
 577
 578         nfmsg = nlmsg_data(nlh);
 579         nfmsg->nfgen_family     = family;
 580         nfmsg->version          = NFNETLINK_V0;
 581         nfmsg->res_id           = 0;
 582
 583         if (nla_put_string(skb, NFTA_CHAIN_TABLE, table->name))
 584                 goto nla_put_failure;
 585         if (nla_put_be64(skb, NFTA_CHAIN_HANDLE, cpu_to_be64(chain->handle)))
 586                 goto nla_put_failure;
 587         if (nla_put_string(skb, NFTA_CHAIN_NAME, chain->name))
 588                 goto nla_put_failure;
 589
 590         if (chain->flags & NFT_BASE_CHAIN) {
 591                 const struct nft_base_chain *basechain = nft_base_chain(chain);
 592                 const struct nf_hook_ops *ops = &basechain->ops;
 593                 struct nlattr *nest;
 594
 595                 nest = nla_nest_start(skb, NFTA_CHAIN_HOOK);
 596                 if (nest == NULL)
 597                         goto nla_put_failure;
 598                 if (nla_put_be32(skb, NFTA_HOOK_HOOKNUM, htonl(ops->hooknum)))
 599                         goto nla_put_failure;
 600                 if (nla_put_be32(skb, NFTA_HOOK_PRIORITY, htonl(ops->priority)))
 601                         goto nla_put_failure;
 602                 nla_nest_end(skb, nest);
 603
 604                 if (nla_put_be32(skb, NFTA_CHAIN_POLICY,
 605                                  htonl(basechain->policy)))
 606                         goto nla_put_failure;
 607
 608                 if (nla_put_string(skb, NFTA_CHAIN_TYPE,
 609                         chain_type[ops->pf][nft_base_chain(chain)->type]->name))
 610                                 goto nla_put_failure;
 611
 612                 if (nft_dump_stats(skb, nft_base_chain(chain)->stats))
 613                         goto nla_put_failure;
 614         }
 615
 616         if (nla_put_be32(skb, NFTA_CHAIN_USE, htonl(chain->use)))
 617                 goto nla_put_failure;
 618
 619         return nlmsg_end(skb, nlh);
 620
 621 nla_put_failure:
 622         nlmsg_trim(skb, nlh);
 623         return -1;
 624 }
 625
 626 static int nf_tables_chain_notify(const struct sk_buff *oskb,
 627                                   const struct nlmsghdr *nlh,
 628                                   const struct nft_table *table,
 629                                   const struct nft_chain *chain,
 630                                   int event, int family)
 631 {
 632         struct sk_buff *skb;
 633         u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;
 634         struct net *net = oskb ? sock_net(oskb->sk) : &init_net;
 635         u32 seq = nlh ? nlh->nlmsg_seq : 0;
 636         bool report;
 637         int err;
 638
 639         report = nlh ? nlmsg_report(nlh) : false;
 640         if (!report && !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
 641                 return 0;
 642
 643         err = -ENOBUFS;
 644         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
 645         if (skb == NULL)
 646                 goto err;
 647
 648         err = nf_tables_fill_chain_info(skb, portid, seq, event, 0, family,
 649                                         table, chain);
 650         if (err < 0) {
 651                 kfree_skb(skb);
 652                 goto err;
 653         }
 654
 655         err = nfnetlink_send(skb, net, portid, NFNLGRP_NFTABLES, report,
 656                              GFP_KERNEL);
 657 err:
 658         if (err < 0)
 659                 nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, err);
 660         return err;
 661 }
 662
 663 static int nf_tables_dump_chains(struct sk_buff *skb,
 664                                  struct netlink_callback *cb)
 665 {
 666         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
 667         const struct nft_af_info *afi;
 668         const struct nft_table *table;
 669         const struct nft_chain *chain;
 670         unsigned int idx = 0, s_idx = cb->args[0];
 671         struct net *net = sock_net(skb->sk);
 672         int family = nfmsg->nfgen_family;
 673
 674         list_for_each_entry(afi, &net->nft.af_info, list) {
 675                 if (family != NFPROTO_UNSPEC && family != afi->family)
 676                         continue;
 677
 678                 list_for_each_entry(table, &afi->tables, list) {
 679                         list_for_each_entry(chain, &table->chains, list) {
 680                                 if (idx < s_idx)
 681                                         goto cont;
 682                                 if (idx > s_idx)
 683                                         memset(&cb->args[1], 0,
 684                                                sizeof(cb->args) - sizeof(cb->args[0]));
 685                                 if (nf_tables_fill_chain_info(skb, NETLINK_CB(cb->skb).portid,
 686                                                               cb->nlh->nlmsg_seq,
 687                                                               NFT_MSG_NEWCHAIN,
 688                                                               NLM_F_MULTI,
 689                                                               afi->family, table, chain) < 0)
 690                                         goto done;
 691 cont:
 692                                 idx++;
 693                         }
 694                 }
 695         }
 696 done:
 697         cb->args[0] = idx;
 698         return skb->len;
 699 }
 700
 701
 702 static int nf_tables_getchain(struct sock *nlsk, struct sk_buff *skb,
 703                               const struct nlmsghdr *nlh,
 704                               const struct nlattr * const nla[])
 705 {
 706         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
 707         const struct nft_af_info *afi;
 708         const struct nft_table *table;
 709         const struct nft_chain *chain;
 710         struct sk_buff *skb2;
 711         struct net *net = sock_net(skb->sk);
 712         int family = nfmsg->nfgen_family;
 713         int err;
 714
 715         if (nlh->nlmsg_flags & NLM_F_DUMP) {
 716                 struct netlink_dump_control c = {
 717                         .dump = nf_tables_dump_chains,
 718                 };
 719                 return netlink_dump_start(nlsk, skb, nlh, &c);
 720         }
 721
 722         afi = nf_tables_afinfo_lookup(net, family, false);
 723         if (IS_ERR(afi))
 724                 return PTR_ERR(afi);
 725
 726         table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE]);
 727         if (IS_ERR(table))
 728                 return PTR_ERR(table);
 729
 730         chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME]);
 731         if (IS_ERR(chain))
 732                 return PTR_ERR(chain);
 733
 734         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
 735         if (!skb2)
 736                 return -ENOMEM;
 737
 738         err = nf_tables_fill_chain_info(skb2, NETLINK_CB(skb).portid,
 739                                         nlh->nlmsg_seq, NFT_MSG_NEWCHAIN, 0,
 740                                         family, table, chain);
 741         if (err < 0)
 742                 goto err;
 743
 744         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
 745
 746 err:
 747         kfree_skb(skb2);
 748         return err;
 749 }
 750
 751 static int
 752 nf_tables_chain_policy(struct nft_base_chain *chain, const struct nlattr *attr)
 753 {
 754         switch (ntohl(nla_get_be32(attr))) {
 755         case NF_DROP:
 756                 chain->policy = NF_DROP;
 757                 break;
 758         case NF_ACCEPT:
 759                 chain->policy = NF_ACCEPT;
 760                 break;
 761         default:
 762                 return -EINVAL;
 763         }
 764         return 0;
 765 }
 766
 767 static const struct nla_policy nft_counter_policy[NFTA_COUNTER_MAX + 1] = {
 768         [NFTA_COUNTER_PACKETS]  = { .type = NLA_U64 },
 769         [NFTA_COUNTER_BYTES]    = { .type = NLA_U64 },
 770 };
 771
 772 static int
 773 nf_tables_counters(struct nft_base_chain *chain, const struct nlattr *attr)
 774 {
 775         struct nlattr *tb[NFTA_COUNTER_MAX+1];
 776         struct nft_stats __percpu *newstats;
 777         struct nft_stats *stats;
 778         int err;
 779
 780         err = nla_parse_nested(tb, NFTA_COUNTER_MAX, attr, nft_counter_policy);
 781         if (err < 0)
 782                 return err;
 783
 784         if (!tb[NFTA_COUNTER_BYTES] || !tb[NFTA_COUNTER_PACKETS])
 785                 return -EINVAL;
 786
 787         newstats = alloc_percpu(struct nft_stats);
 788         if (newstats == NULL)
 789                 return -ENOMEM;
 790
 791         /* Restore old counters on this cpu, no problem. Per-cpu statistics
 792          * are not exposed to userspace.
 793          */
 794         stats = this_cpu_ptr(newstats);
 795         stats->bytes = be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_BYTES]));
 796         stats->pkts = be64_to_cpu(nla_get_be64(tb[NFTA_COUNTER_PACKETS]));
 797
 798         if (chain->stats) {
 799                 /* nfnl_lock is held, add some nfnl function for this, later */
 800                 struct nft_stats __percpu *oldstats =
 801                         rcu_dereference_protected(chain->stats, 1);
 802
 803                 rcu_assign_pointer(chain->stats, newstats);
 804                 synchronize_rcu();
 805                 free_percpu(oldstats);
 806         } else
 807                 rcu_assign_pointer(chain->stats, newstats);
 808
 809         return 0;
 810 }
 811
 812 static int nf_tables_newchain(struct sock *nlsk, struct sk_buff *skb,
 813                               const struct nlmsghdr *nlh,
 814                               const struct nlattr * const nla[])
 815 {
 816         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
 817         const struct nlattr * uninitialized_var(name);
 818         const struct nft_af_info *afi;
 819         struct nft_table *table;
 820         struct nft_chain *chain;
 821         struct nft_base_chain *basechain = NULL;
 822         struct nlattr *ha[NFTA_HOOK_MAX + 1];
 823         struct net *net = sock_net(skb->sk);
 824         int family = nfmsg->nfgen_family;
 825         u64 handle = 0;
 826         int err;
 827         bool create;
 828
 829         create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false;
 830
 831         afi = nf_tables_afinfo_lookup(net, family, true);
 832         if (IS_ERR(afi))
 833                 return PTR_ERR(afi);
 834
 835         table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE]);
 836         if (IS_ERR(table))
 837                 return PTR_ERR(table);
 838
 839         if (table->use == UINT_MAX)
 840                 return -EOVERFLOW;
 841
 842         chain = NULL;
 843         name = nla[NFTA_CHAIN_NAME];
 844
 845         if (nla[NFTA_CHAIN_HANDLE]) {
 846                 handle = be64_to_cpu(nla_get_be64(nla[NFTA_CHAIN_HANDLE]));
 847                 chain = nf_tables_chain_lookup_byhandle(table, handle);
 848                 if (IS_ERR(chain))
 849                         return PTR_ERR(chain);
 850         } else {
 851                 chain = nf_tables_chain_lookup(table, name);
 852                 if (IS_ERR(chain)) {
 853                         if (PTR_ERR(chain) != -ENOENT)
 854                                 return PTR_ERR(chain);
 855                         chain = NULL;
 856                 }
 857         }
 858
 859         if (chain != NULL) {
 860                 if (nlh->nlmsg_flags & NLM_F_EXCL)
 861                         return -EEXIST;
 862                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
 863                         return -EOPNOTSUPP;
 864
 865                 if (nla[NFTA_CHAIN_HANDLE] && name &&
 866                     !IS_ERR(nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME])))
 867                         return -EEXIST;
 868
 869                 if (nla[NFTA_CHAIN_POLICY]) {
 870                         if (!(chain->flags & NFT_BASE_CHAIN))
 871                                 return -EOPNOTSUPP;
 872
 873                         err = nf_tables_chain_policy(nft_base_chain(chain),
 874                                                      nla[NFTA_CHAIN_POLICY]);
 875                         if (err < 0)
 876                                 return err;
 877                 }
 878
 879                 if (nla[NFTA_CHAIN_COUNTERS]) {
 880                         if (!(chain->flags & NFT_BASE_CHAIN))
 881                                 return -EOPNOTSUPP;
 882
 883                         err = nf_tables_counters(nft_base_chain(chain),
 884                                                  nla[NFTA_CHAIN_COUNTERS]);
 885                         if (err < 0)
 886                                 return err;
 887                 }
 888
 889                 if (nla[NFTA_CHAIN_HANDLE] && name)
 890                         nla_strlcpy(chain->name, name, NFT_CHAIN_MAXNAMELEN);
 891
 892                 goto notify;
 893         }
 894
 895         if (nla[NFTA_CHAIN_HOOK]) {
 896                 struct nf_hook_ops *ops;
 897                 nf_hookfn *hookfn;
 898                 u32 hooknum;
 899                 int type = NFT_CHAIN_T_DEFAULT;
 900
 901                 if (nla[NFTA_CHAIN_TYPE]) {
 902                         type = nf_tables_chain_type_lookup(afi,
 903                                                            nla[NFTA_CHAIN_TYPE],
 904                                                            create);
 905                         if (type < 0)
 906                                 return -ENOENT;
 907                 }
 908
 909                 err = nla_parse_nested(ha, NFTA_HOOK_MAX, nla[NFTA_CHAIN_HOOK],
 910                                        nft_hook_policy);
 911                 if (err < 0)
 912                         return err;
 913                 if (ha[NFTA_HOOK_HOOKNUM] == NULL ||
 914                     ha[NFTA_HOOK_PRIORITY] == NULL)
 915                         return -EINVAL;
 916
 917                 hooknum = ntohl(nla_get_be32(ha[NFTA_HOOK_HOOKNUM]));
 918                 if (hooknum >= afi->nhooks)
 919                         return -EINVAL;
 920
 921                 hookfn = chain_type[family][type]->fn[hooknum];
 922                 if (hookfn == NULL)
 923                         return -EOPNOTSUPP;
 924
 925                 basechain = kzalloc(sizeof(*basechain), GFP_KERNEL);
 926                 if (basechain == NULL)
 927                         return -ENOMEM;
 928
 929                 basechain->type = type;
 930                 chain = &basechain->chain;
 931
 932                 ops = &basechain->ops;
 933                 ops->pf         = family;
 934                 ops->owner      = afi->owner;
 935                 ops->hooknum    = ntohl(nla_get_be32(ha[NFTA_HOOK_HOOKNUM]));
 936                 ops->priority   = ntohl(nla_get_be32(ha[NFTA_HOOK_PRIORITY]));
 937                 ops->priv       = chain;
 938                 ops->hook       = hookfn;
 939                 if (afi->hooks[ops->hooknum])
 940                         ops->hook = afi->hooks[ops->hooknum];
 941
 942                 chain->flags |= NFT_BASE_CHAIN;
 943
 944                 if (nla[NFTA_CHAIN_POLICY]) {
 945                         err = nf_tables_chain_policy(basechain,
 946                                                      nla[NFTA_CHAIN_POLICY]);
 947                         if (err < 0) {
 948                                 free_percpu(basechain->stats);
 949                                 kfree(basechain);
 950                                 return err;
 951                         }
 952                 } else
 953                         basechain->policy = NF_ACCEPT;
 954
 955                 if (nla[NFTA_CHAIN_COUNTERS]) {
 956                         err = nf_tables_counters(basechain,
 957                                                  nla[NFTA_CHAIN_COUNTERS]);
 958                         if (err < 0) {
 959                                 free_percpu(basechain->stats);
 960                                 kfree(basechain);
 961                                 return err;
 962                         }
 963                 } else {
 964                         struct nft_stats __percpu *newstats;
 965
 966                         newstats = alloc_percpu(struct nft_stats);
 967                         if (newstats == NULL)
 968                                 return -ENOMEM;
 969
 970                         rcu_assign_pointer(nft_base_chain(chain)->stats,
 971                                            newstats);
 972                 }
 973         } else {
 974                 chain = kzalloc(sizeof(*chain), GFP_KERNEL);
 975                 if (chain == NULL)
 976                         return -ENOMEM;
 977         }
 978
 979         INIT_LIST_HEAD(&chain->rules);
 980         chain->handle = nf_tables_alloc_handle(table);
 981         chain->net = net;
 982         chain->table = table;
 983         nla_strlcpy(chain->name, name, NFT_CHAIN_MAXNAMELEN);
 984
 985         if (!(table->flags & NFT_TABLE_F_DORMANT) &&
 986             chain->flags & NFT_BASE_CHAIN) {
 987                 err = nf_register_hook(&nft_base_chain(chain)->ops);
 988                 if (err < 0) {
 989                         free_percpu(basechain->stats);
 990                         kfree(basechain);
 991                         return err;
 992                 }
 993         }
 994         list_add_tail(&chain->list, &table->chains);
 995         table->use++;
 996 notify:
 997         nf_tables_chain_notify(skb, nlh, table, chain, NFT_MSG_NEWCHAIN,
 998                                family);
 999         return 0;
1000 }
1001
1002 static void nf_tables_rcu_chain_destroy(struct rcu_head *head)
1003 {
1004         struct nft_chain *chain = container_of(head, struct nft_chain, rcu_head);
1005
1006         BUG_ON(chain->use > 0);
1007
1008         if (chain->flags & NFT_BASE_CHAIN) {
1009                 free_percpu(nft_base_chain(chain)->stats);
1010                 kfree(nft_base_chain(chain));
1011         } else
1012                 kfree(chain);
1013 }
1014
1015 static int nf_tables_delchain(struct sock *nlsk, struct sk_buff *skb,
1016                               const struct nlmsghdr *nlh,
1017                               const struct nlattr * const nla[])
1018 {
1019         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1020         const struct nft_af_info *afi;
1021         struct nft_table *table;
1022         struct nft_chain *chain;
1023         struct net *net = sock_net(skb->sk);
1024         int family = nfmsg->nfgen_family;
1025
1026         afi = nf_tables_afinfo_lookup(net, family, false);
1027         if (IS_ERR(afi))
1028                 return PTR_ERR(afi);
1029
1030         table = nf_tables_table_lookup(afi, nla[NFTA_CHAIN_TABLE]);
1031         if (IS_ERR(table))
1032                 return PTR_ERR(table);
1033
1034         chain = nf_tables_chain_lookup(table, nla[NFTA_CHAIN_NAME]);
1035         if (IS_ERR(chain))
1036                 return PTR_ERR(chain);
1037
1038         if (!list_empty(&chain->rules))
1039                 return -EBUSY;
1040
1041         list_del(&chain->list);
1042         table->use--;
1043
1044         if (!(table->flags & NFT_TABLE_F_DORMANT) &&
1045             chain->flags & NFT_BASE_CHAIN)
1046                 nf_unregister_hook(&nft_base_chain(chain)->ops);
1047
1048         nf_tables_chain_notify(skb, nlh, table, chain, NFT_MSG_DELCHAIN,
1049                                family);
1050
1051         /* Make sure all rule references are gone before this is released */
1052         call_rcu(&chain->rcu_head, nf_tables_rcu_chain_destroy);
1053         return 0;
1054 }
1055
1056 static void nft_ctx_init(struct nft_ctx *ctx,
1057                          const struct sk_buff *skb,
1058                          const struct nlmsghdr *nlh,
1059                          const struct nft_af_info *afi,
1060                          const struct nft_table *table,
1061                          const struct nft_chain *chain,
1062                          const struct nlattr * const *nla)
1063 {
1064         ctx->net   = sock_net(skb->sk);
1065         ctx->skb   = skb;
1066         ctx->nlh   = nlh;
1067         ctx->afi   = afi;
1068         ctx->table = table;
1069         ctx->chain = chain;
1070         ctx->nla   = nla;
1071 }
1072
1073 /*
1074  * Expressions
1075  */
1076
1077 /**
1078  *      nft_register_expr - register nf_tables expr type
1079  *      @ops: expr type
1080  *
1081  *      Registers the expr type for use with nf_tables. Returns zero on
1082  *      success or a negative errno code otherwise.
1083  */
1084 int nft_register_expr(struct nft_expr_type *type)
1085 {
1086         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1087         list_add_tail(&type->list, &nf_tables_expressions);
1088         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1089         return 0;
1090 }
1091 EXPORT_SYMBOL_GPL(nft_register_expr);
1092
1093 /**
1094  *      nft_unregister_expr - unregister nf_tables expr type
1095  *      @ops: expr type
1096  *
1097  *      Unregisters the expr typefor use with nf_tables.
1098  */
1099 void nft_unregister_expr(struct nft_expr_type *type)
1100 {
1101         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1102         list_del(&type->list);
1103         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1104 }
1105 EXPORT_SYMBOL_GPL(nft_unregister_expr);
1106
1107 static const struct nft_expr_type *__nft_expr_type_get(struct nlattr *nla)
1108 {
1109         const struct nft_expr_type *type;
1110
1111         list_for_each_entry(type, &nf_tables_expressions, list) {
1112                 if (!nla_strcmp(nla, type->name))
1113                         return type;
1114         }
1115         return NULL;
1116 }
1117
1118 static const struct nft_expr_type *nft_expr_type_get(struct nlattr *nla)
1119 {
1120         const struct nft_expr_type *type;
1121
1122         if (nla == NULL)
1123                 return ERR_PTR(-EINVAL);
1124
1125         type = __nft_expr_type_get(nla);
1126         if (type != NULL && try_module_get(type->owner))
1127                 return type;
1128
1129 #ifdef CONFIG_MODULES
1130         if (type == NULL) {
1131                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1132                 request_module("nft-expr-%.*s",
1133                                nla_len(nla), (char *)nla_data(nla));
1134                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
1135                 if (__nft_expr_type_get(nla))
1136                         return ERR_PTR(-EAGAIN);
1137         }
1138 #endif
1139         return ERR_PTR(-ENOENT);
1140 }
1141
1142 static const struct nla_policy nft_expr_policy[NFTA_EXPR_MAX + 1] = {
1143         [NFTA_EXPR_NAME]        = { .type = NLA_STRING },
1144         [NFTA_EXPR_DATA]        = { .type = NLA_NESTED },
1145 };
1146
1147 static int nf_tables_fill_expr_info(struct sk_buff *skb,
1148                                     const struct nft_expr *expr)
1149 {
1150         if (nla_put_string(skb, NFTA_EXPR_NAME, expr->ops->type->name))
1151                 goto nla_put_failure;
1152
1153         if (expr->ops->dump) {
1154                 struct nlattr *data = nla_nest_start(skb, NFTA_EXPR_DATA);
1155                 if (data == NULL)
1156                         goto nla_put_failure;
1157                 if (expr->ops->dump(skb, expr) < 0)
1158                         goto nla_put_failure;
1159                 nla_nest_end(skb, data);
1160         }
1161
1162         return skb->len;
1163
1164 nla_put_failure:
1165         return -1;
1166 };
1167
1168 struct nft_expr_info {
1169         const struct nft_expr_ops       *ops;
1170         struct nlattr                   *tb[NFT_EXPR_MAXATTR + 1];
1171 };
1172
1173 static int nf_tables_expr_parse(const struct nft_ctx *ctx,
1174                                 const struct nlattr *nla,
1175                                 struct nft_expr_info *info)
1176 {
1177         const struct nft_expr_type *type;
1178         const struct nft_expr_ops *ops;
1179         struct nlattr *tb[NFTA_EXPR_MAX + 1];
1180         int err;
1181
1182         err = nla_parse_nested(tb, NFTA_EXPR_MAX, nla, nft_expr_policy);
1183         if (err < 0)
1184                 return err;
1185
1186         type = nft_expr_type_get(tb[NFTA_EXPR_NAME]);
1187         if (IS_ERR(type))
1188                 return PTR_ERR(type);
1189
1190         if (tb[NFTA_EXPR_DATA]) {
1191                 err = nla_parse_nested(info->tb, type->maxattr,
1192                                        tb[NFTA_EXPR_DATA], type->policy);
1193                 if (err < 0)
1194                         goto err1;
1195         } else
1196                 memset(info->tb, 0, sizeof(info->tb[0]) * (type->maxattr + 1));
1197
1198         if (type->select_ops != NULL) {
1199                 ops = type->select_ops(ctx,
1200                                        (const struct nlattr * const *)info->tb);
1201                 if (IS_ERR(ops)) {
1202                         err = PTR_ERR(ops);
1203                         goto err1;
1204                 }
1205         } else
1206                 ops = type->ops;
1207
1208         info->ops = ops;
1209         return 0;
1210
1211 err1:
1212         module_put(type->owner);
1213         return err;
1214 }
1215
1216 static int nf_tables_newexpr(const struct nft_ctx *ctx,
1217                              const struct nft_expr_info *info,
1218                              struct nft_expr *expr)
1219 {
1220         const struct nft_expr_ops *ops = info->ops;
1221         int err;
1222
1223         expr->ops = ops;
1224         if (ops->init) {
1225                 err = ops->init(ctx, expr, (const struct nlattr **)info->tb);
1226                 if (err < 0)
1227                         goto err1;
1228         }
1229
1230         return 0;
1231
1232 err1:
1233         expr->ops = NULL;
1234         return err;
1235 }
1236
1237 static void nf_tables_expr_destroy(struct nft_expr *expr)
1238 {
1239         if (expr->ops->destroy)
1240                 expr->ops->destroy(expr);
1241         module_put(expr->ops->type->owner);
1242 }
1243
1244 /*
1245  * Rules
1246  */
1247
1248 static struct nft_rule *__nf_tables_rule_lookup(const struct nft_chain *chain,
1249                                                 u64 handle)
1250 {
1251         struct nft_rule *rule;
1252
1253         // FIXME: this sucks
1254         list_for_each_entry(rule, &chain->rules, list) {
1255                 if (handle == rule->handle)
1256                         return rule;
1257         }
1258
1259         return ERR_PTR(-ENOENT);
1260 }
1261
1262 static struct nft_rule *nf_tables_rule_lookup(const struct nft_chain *chain,
1263                                               const struct nlattr *nla)
1264 {
1265         if (nla == NULL)
1266                 return ERR_PTR(-EINVAL);
1267
1268         return __nf_tables_rule_lookup(chain, be64_to_cpu(nla_get_be64(nla)));
1269 }
1270
1271 static const struct nla_policy nft_rule_policy[NFTA_RULE_MAX + 1] = {
1272         [NFTA_RULE_TABLE]       = { .type = NLA_STRING },
1273         [NFTA_RULE_CHAIN]       = { .type = NLA_STRING,
1274                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
1275         [NFTA_RULE_HANDLE]      = { .type = NLA_U64 },
1276         [NFTA_RULE_EXPRESSIONS] = { .type = NLA_NESTED },
1277         [NFTA_RULE_COMPAT]      = { .type = NLA_NESTED },
1278         [NFTA_RULE_POSITION]    = { .type = NLA_U64 },
1279 };
1280
1281 static int nf_tables_fill_rule_info(struct sk_buff *skb, u32 portid, u32 seq,
1282                                     int event, u32 flags, int family,
1283                                     const struct nft_table *table,
1284                                     const struct nft_chain *chain,
1285                                     const struct nft_rule *rule)
1286 {
1287         struct nlmsghdr *nlh;
1288         struct nfgenmsg *nfmsg;
1289         const struct nft_expr *expr, *next;
1290         struct nlattr *list;
1291         const struct nft_rule *prule;
1292         int type = event | NFNL_SUBSYS_NFTABLES << 8;
1293
1294         nlh = nlmsg_put(skb, portid, seq, type, sizeof(struct nfgenmsg),
1295                         flags);
1296         if (nlh == NULL)
1297                 goto nla_put_failure;
1298
1299         nfmsg = nlmsg_data(nlh);
1300         nfmsg->nfgen_family     = family;
1301         nfmsg->version          = NFNETLINK_V0;
1302         nfmsg->res_id           = 0;
1303
1304         if (nla_put_string(skb, NFTA_RULE_TABLE, table->name))
1305                 goto nla_put_failure;
1306         if (nla_put_string(skb, NFTA_RULE_CHAIN, chain->name))
1307                 goto nla_put_failure;
1308         if (nla_put_be64(skb, NFTA_RULE_HANDLE, cpu_to_be64(rule->handle)))
1309                 goto nla_put_failure;
1310
1311         if ((event != NFT_MSG_DELRULE) && (rule->list.prev != &chain->rules)) {
1312                 prule = list_entry(rule->list.prev, struct nft_rule, list);
1313                 if (nla_put_be64(skb, NFTA_RULE_POSITION,
1314                                  cpu_to_be64(prule->handle)))
1315                         goto nla_put_failure;
1316         }
1317
1318         list = nla_nest_start(skb, NFTA_RULE_EXPRESSIONS);
1319         if (list == NULL)
1320                 goto nla_put_failure;
1321         nft_rule_for_each_expr(expr, next, rule) {
1322                 struct nlattr *elem = nla_nest_start(skb, NFTA_LIST_ELEM);
1323                 if (elem == NULL)
1324                         goto nla_put_failure;
1325                 if (nf_tables_fill_expr_info(skb, expr) < 0)
1326                         goto nla_put_failure;
1327                 nla_nest_end(skb, elem);
1328         }
1329         nla_nest_end(skb, list);
1330
1331         return nlmsg_end(skb, nlh);
1332
1333 nla_put_failure:
1334         nlmsg_trim(skb, nlh);
1335         return -1;
1336 }
1337
1338 static int nf_tables_rule_notify(const struct sk_buff *oskb,
1339                                  const struct nlmsghdr *nlh,
1340                                  const struct nft_table *table,
1341                                  const struct nft_chain *chain,
1342                                  const struct nft_rule *rule,
1343                                  int event, u32 flags, int family)
1344 {
1345         struct sk_buff *skb;
1346         u32 portid = NETLINK_CB(oskb).portid;
1347         struct net *net = oskb ? sock_net(oskb->sk) : &init_net;
1348         u32 seq = nlh->nlmsg_seq;
1349         bool report;
1350         int err;
1351
1352         report = nlmsg_report(nlh);
1353         if (!report && !nfnetlink_has_listeners(net, NFNLGRP_NFTABLES))
1354                 return 0;
1355
1356         err = -ENOBUFS;
1357         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
1358         if (skb == NULL)
1359                 goto err;
1360
1361         err = nf_tables_fill_rule_info(skb, portid, seq, event, flags,
1362                                        family, table, chain, rule);
1363         if (err < 0) {
1364                 kfree_skb(skb);
1365                 goto err;
1366         }
1367
1368         err = nfnetlink_send(skb, net, portid, NFNLGRP_NFTABLES, report,
1369                              GFP_KERNEL);
1370 err:
1371         if (err < 0)
1372                 nfnetlink_set_err(net, portid, NFNLGRP_NFTABLES, err);
1373         return err;
1374 }
1375
1376 static inline bool
1377 nft_rule_is_active(struct net *net, const struct nft_rule *rule)
1378 {
1379         return (rule->genmask & (1 << net->nft.gencursor)) == 0;
1380 }
1381
1382 static inline int gencursor_next(struct net *net)
1383 {
1384         return net->nft.gencursor+1 == 1 ? 1 : 0;
1385 }
1386
1387 static inline int
1388 nft_rule_is_active_next(struct net *net, const struct nft_rule *rule)
1389 {
1390         return (rule->genmask & (1 << gencursor_next(net))) == 0;
1391 }
1392
1393 static inline void
1394 nft_rule_activate_next(struct net *net, struct nft_rule *rule)
1395 {
1396         /* Now inactive, will be active in the future */
1397         rule->genmask = (1 << net->nft.gencursor);
1398 }
1399
1400 static inline void
1401 nft_rule_disactivate_next(struct net *net, struct nft_rule *rule)
1402 {
1403         rule->genmask = (1 << gencursor_next(net));
1404 }
1405
1406 static inline void nft_rule_clear(struct net *net, struct nft_rule *rule)
1407 {
1408         rule->genmask = 0;
1409 }
1410
1411 static int nf_tables_dump_rules(struct sk_buff *skb,
1412                                 struct netlink_callback *cb)
1413 {
1414         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
1415         const struct nft_af_info *afi;
1416         const struct nft_table *table;
1417         const struct nft_chain *chain;
1418         const struct nft_rule *rule;
1419         unsigned int idx = 0, s_idx = cb->args[0];
1420         struct net *net = sock_net(skb->sk);
1421         int family = nfmsg->nfgen_family;
1422         u8 genctr = ACCESS_ONCE(net->nft.genctr);
1423         u8 gencursor = ACCESS_ONCE(net->nft.gencursor);
1424
1425         list_for_each_entry(afi, &net->nft.af_info, list) {
1426                 if (family != NFPROTO_UNSPEC && family != afi->family)
1427                         continue;
1428
1429                 list_for_each_entry(table, &afi->tables, list) {
1430                         list_for_each_entry(chain, &table->chains, list) {
1431                                 list_for_each_entry(rule, &chain->rules, list) {
1432                                         if (!nft_rule_is_active(net, rule))
1433                                                 goto cont;
1434                                         if (idx < s_idx)
1435                                                 goto cont;
1436                                         if (idx > s_idx)
1437                                                 memset(&cb->args[1], 0,
1438                                                        sizeof(cb->args) - sizeof(cb->args[0]));
1439                                         if (nf_tables_fill_rule_info(skb, NETLINK_CB(cb->skb).portid,
1440                                                                       cb->nlh->nlmsg_seq,
1441                                                                       NFT_MSG_NEWRULE,
1442                                                                       NLM_F_MULTI | NLM_F_APPEND,
1443                                                                       afi->family, table, chain, rule) < 0)
1444                                                 goto done;
1445 cont:
1446                                         idx++;
1447                                 }
1448                         }
1449                 }
1450         }
1451 done:
1452         /* Invalidate this dump, a transition to the new generation happened */
1453         if (gencursor != net->nft.gencursor || genctr != net->nft.genctr)
1454                 return -EBUSY;
1455
1456         cb->args[0] = idx;
1457         return skb->len;
1458 }
1459
1460 static int nf_tables_getrule(struct sock *nlsk, struct sk_buff *skb,
1461                              const struct nlmsghdr *nlh,
1462                              const struct nlattr * const nla[])
1463 {
1464         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1465         const struct nft_af_info *afi;
1466         const struct nft_table *table;
1467         const struct nft_chain *chain;
1468         const struct nft_rule *rule;
1469         struct sk_buff *skb2;
1470         struct net *net = sock_net(skb->sk);
1471         int family = nfmsg->nfgen_family;
1472         int err;
1473
1474         if (nlh->nlmsg_flags & NLM_F_DUMP) {
1475                 struct netlink_dump_control c = {
1476                         .dump = nf_tables_dump_rules,
1477                 };
1478                 return netlink_dump_start(nlsk, skb, nlh, &c);
1479         }
1480
1481         afi = nf_tables_afinfo_lookup(net, family, false);
1482         if (IS_ERR(afi))
1483                 return PTR_ERR(afi);
1484
1485         table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE]);
1486         if (IS_ERR(table))
1487                 return PTR_ERR(table);
1488
1489         chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN]);
1490         if (IS_ERR(chain))
1491                 return PTR_ERR(chain);
1492
1493         rule = nf_tables_rule_lookup(chain, nla[NFTA_RULE_HANDLE]);
1494         if (IS_ERR(rule))
1495                 return PTR_ERR(rule);
1496
1497         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
1498         if (!skb2)
1499                 return -ENOMEM;
1500
1501         err = nf_tables_fill_rule_info(skb2, NETLINK_CB(skb).portid,
1502                                        nlh->nlmsg_seq, NFT_MSG_NEWRULE, 0,
1503                                        family, table, chain, rule);
1504         if (err < 0)
1505                 goto err;
1506
1507         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
1508
1509 err:
1510         kfree_skb(skb2);
1511         return err;
1512 }
1513
1514 static void nf_tables_rcu_rule_destroy(struct rcu_head *head)
1515 {
1516         struct nft_rule *rule = container_of(head, struct nft_rule, rcu_head);
1517         struct nft_expr *expr;
1518
1519         /*
1520          * Careful: some expressions might not be initialized in case this
1521          * is called on error from nf_tables_newrule().
1522          */
1523         expr = nft_expr_first(rule);
1524         while (expr->ops && expr != nft_expr_last(rule)) {
1525                 nf_tables_expr_destroy(expr);
1526                 expr = nft_expr_next(expr);
1527         }
1528         kfree(rule);
1529 }
1530
1531 static void nf_tables_rule_destroy(struct nft_rule *rule)
1532 {
1533         call_rcu(&rule->rcu_head, nf_tables_rcu_rule_destroy);
1534 }
1535
1536 #define NFT_RULE_MAXEXPRS       128
1537
1538 static struct nft_expr_info *info;
1539
1540 static struct nft_rule_trans *
1541 nf_tables_trans_add(struct nft_rule *rule, const struct nft_ctx *ctx)
1542 {
1543         struct nft_rule_trans *rupd;
1544
1545         rupd = kmalloc(sizeof(struct nft_rule_trans), GFP_KERNEL);
1546         if (rupd == NULL)
1547                return NULL;
1548
1549         rupd->chain = ctx->chain;
1550         rupd->table = ctx->table;
1551         rupd->rule = rule;
1552         rupd->family = ctx->afi->family;
1553         rupd->nlh = ctx->nlh;
1554         list_add_tail(&rupd->list, &ctx->net->nft.commit_list);
1555
1556         return rupd;
1557 }
1558
1559 static int nf_tables_newrule(struct sock *nlsk, struct sk_buff *skb,
1560                              const struct nlmsghdr *nlh,
1561                              const struct nlattr * const nla[])
1562 {
1563         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1564         const struct nft_af_info *afi;
1565         struct net *net = sock_net(skb->sk);
1566         struct nft_table *table;
1567         struct nft_chain *chain;
1568         struct nft_rule *rule, *old_rule = NULL;
1569         struct nft_rule_trans *repl = NULL;
1570         struct nft_expr *expr;
1571         struct nft_ctx ctx;
1572         struct nlattr *tmp;
1573         unsigned int size, i, n;
1574         int err, rem;
1575         bool create;
1576         u64 handle, pos_handle;
1577
1578         create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false;
1579
1580         afi = nf_tables_afinfo_lookup(net, nfmsg->nfgen_family, create);
1581         if (IS_ERR(afi))
1582                 return PTR_ERR(afi);
1583
1584         table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE]);
1585         if (IS_ERR(table))
1586                 return PTR_ERR(table);
1587
1588         chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN]);
1589         if (IS_ERR(chain))
1590                 return PTR_ERR(chain);
1591
1592         if (nla[NFTA_RULE_HANDLE]) {
1593                 handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_HANDLE]));
1594                 rule = __nf_tables_rule_lookup(chain, handle);
1595                 if (IS_ERR(rule))
1596                         return PTR_ERR(rule);
1597
1598                 if (nlh->nlmsg_flags & NLM_F_EXCL)
1599                         return -EEXIST;
1600                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
1601                         old_rule = rule;
1602                 else
1603                         return -EOPNOTSUPP;
1604         } else {
1605                 if (!create || nlh->nlmsg_flags & NLM_F_REPLACE)
1606                         return -EINVAL;
1607                 handle = nf_tables_alloc_handle(table);
1608         }
1609
1610         if (nla[NFTA_RULE_POSITION]) {
1611                 if (!(nlh->nlmsg_flags & NLM_F_CREATE))
1612                         return -EOPNOTSUPP;
1613
1614                 pos_handle = be64_to_cpu(nla_get_be64(nla[NFTA_RULE_POSITION]));
1615                 old_rule = __nf_tables_rule_lookup(chain, pos_handle);
1616                 if (IS_ERR(old_rule))
1617                         return PTR_ERR(old_rule);
1618         }
1619
1620         nft_ctx_init(&ctx, skb, nlh, afi, table, chain, nla);
1621
1622         n = 0;
1623         size = 0;
1624         if (nla[NFTA_RULE_EXPRESSIONS]) {
1625                 nla_for_each_nested(tmp, nla[NFTA_RULE_EXPRESSIONS], rem) {
1626                         err = -EINVAL;
1627                         if (nla_type(tmp) != NFTA_LIST_ELEM)
1628                                 goto err1;
1629                         if (n == NFT_RULE_MAXEXPRS)
1630                                 goto err1;
1631                         err = nf_tables_expr_parse(&ctx, tmp, &info[n]);
1632                         if (err < 0)
1633                                 goto err1;
1634                         size += info[n].ops->size;
1635                         n++;
1636                 }
1637         }
1638
1639         err = -ENOMEM;
1640         rule = kzalloc(sizeof(*rule) + size, GFP_KERNEL);
1641         if (rule == NULL)
1642                 goto err1;
1643
1644         nft_rule_activate_next(net, rule);
1645
1646         rule->handle = handle;
1647         rule->dlen   = size;
1648
1649         expr = nft_expr_first(rule);
1650         for (i = 0; i < n; i++) {
1651                 err = nf_tables_newexpr(&ctx, &info[i], expr);
1652                 if (err < 0)
1653                         goto err2;
1654                 info[i].ops = NULL;
1655                 expr = nft_expr_next(expr);
1656         }
1657
1658         if (nlh->nlmsg_flags & NLM_F_REPLACE) {
1659                 if (nft_rule_is_active_next(net, old_rule)) {
1660                         repl = nf_tables_trans_add(old_rule, &ctx);
1661                         if (repl == NULL) {
1662                                 err = -ENOMEM;
1663                                 goto err2;
1664                         }
1665                         nft_rule_disactivate_next(net, old_rule);
1666                         list_add_tail(&rule->list, &old_rule->list);
1667                 } else {
1668                         err = -ENOENT;
1669                         goto err2;
1670                 }
1671         } else if (nlh->nlmsg_flags & NLM_F_APPEND)
1672                 if (old_rule)
1673                         list_add_rcu(&rule->list, &old_rule->list);
1674                 else
1675                         list_add_tail_rcu(&rule->list, &chain->rules);
1676         else {
1677                 if (old_rule)
1678                         list_add_tail_rcu(&rule->list, &old_rule->list);
1679                 else
1680                         list_add_rcu(&rule->list, &chain->rules);
1681         }
1682
1683         if (nf_tables_trans_add(rule, &ctx) == NULL) {
1684                 err = -ENOMEM;
1685                 goto err3;
1686         }
1687         return 0;
1688
1689 err3:
1690         list_del_rcu(&rule->list);
1691         if (repl) {
1692                 list_del_rcu(&repl->rule->list);
1693                 list_del(&repl->list);
1694                 nft_rule_clear(net, repl->rule);
1695                 kfree(repl);
1696         }
1697 err2:
1698         nf_tables_rule_destroy(rule);
1699 err1:
1700         for (i = 0; i < n; i++) {
1701                 if (info[i].ops != NULL)
1702                         module_put(info[i].ops->type->owner);
1703         }
1704         return err;
1705 }
1706
1707 static int
1708 nf_tables_delrule_one(struct nft_ctx *ctx, struct nft_rule *rule)
1709 {
1710         /* You cannot delete the same rule twice */
1711         if (nft_rule_is_active_next(ctx->net, rule)) {
1712                 if (nf_tables_trans_add(rule, ctx) == NULL)
1713                         return -ENOMEM;
1714                 nft_rule_disactivate_next(ctx->net, rule);
1715                 return 0;
1716         }
1717         return -ENOENT;
1718 }
1719
1720 static int nf_tables_delrule(struct sock *nlsk, struct sk_buff *skb,
1721                              const struct nlmsghdr *nlh,
1722                              const struct nlattr * const nla[])
1723 {
1724         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1725         const struct nft_af_info *afi;
1726         struct net *net = sock_net(skb->sk);
1727         const struct nft_table *table;
1728         struct nft_chain *chain;
1729         struct nft_rule *rule, *tmp;
1730         int family = nfmsg->nfgen_family, err = 0;
1731         struct nft_ctx ctx;
1732
1733         afi = nf_tables_afinfo_lookup(net, family, false);
1734         if (IS_ERR(afi))
1735                 return PTR_ERR(afi);
1736
1737         table = nf_tables_table_lookup(afi, nla[NFTA_RULE_TABLE]);
1738         if (IS_ERR(table))
1739                 return PTR_ERR(table);
1740
1741         chain = nf_tables_chain_lookup(table, nla[NFTA_RULE_CHAIN]);
1742         if (IS_ERR(chain))
1743                 return PTR_ERR(chain);
1744
1745         nft_ctx_init(&ctx, skb, nlh, afi, table, chain, nla);
1746
1747         if (nla[NFTA_RULE_HANDLE]) {
1748                 rule = nf_tables_rule_lookup(chain, nla[NFTA_RULE_HANDLE]);
1749                 if (IS_ERR(rule))
1750                         return PTR_ERR(rule);
1751
1752                 err = nf_tables_delrule_one(&ctx, rule);
1753         } else {
1754                 /* Remove all rules in this chain */
1755                 list_for_each_entry_safe(rule, tmp, &chain->rules, list) {
1756                         err = nf_tables_delrule_one(&ctx, rule);
1757                         if (err < 0)
1758                                 break;
1759                 }
1760         }
1761
1762         return err;
1763 }
1764
1765 static int nf_tables_commit(struct sk_buff *skb)
1766 {
1767         struct net *net = sock_net(skb->sk);
1768         struct nft_rule_trans *rupd, *tmp;
1769
1770         /* Bump generation counter, invalidate any dump in progress */
1771         net->nft.genctr++;
1772
1773         /* A new generation has just started */
1774         net->nft.gencursor = gencursor_next(net);
1775
1776         /* Make sure all packets have left the previous generation before
1777          * purging old rules.
1778          */
1779         synchronize_rcu();
1780
1781         list_for_each_entry_safe(rupd, tmp, &net->nft.commit_list, list) {
1782                 /* Delete this rule from the dirty list */
1783                 list_del(&rupd->list);
1784
1785                 /* This rule was inactive in the past and just became active.
1786                  * Clear the next bit of the genmask since its meaning has
1787                  * changed, now it is the future.
1788                  */
1789                 if (nft_rule_is_active(net, rupd->rule)) {
1790                         nft_rule_clear(net, rupd->rule);
1791                         nf_tables_rule_notify(skb, rupd->nlh, rupd->table,
1792                                               rupd->chain, rupd->rule,
1793                                               NFT_MSG_NEWRULE, 0,
1794                                               rupd->family);
1795                         kfree(rupd);
1796                         continue;
1797                 }
1798
1799                 /* This rule is in the past, get rid of it */
1800                 list_del_rcu(&rupd->rule->list);
1801                 nf_tables_rule_notify(skb, rupd->nlh, rupd->table, rupd->chain,
1802                                       rupd->rule, NFT_MSG_DELRULE, 0,
1803                                       rupd->family);
1804                 nf_tables_rule_destroy(rupd->rule);
1805                 kfree(rupd);
1806         }
1807
1808         return 0;
1809 }
1810
1811 static int nf_tables_abort(struct sk_buff *skb)
1812 {
1813         struct net *net = sock_net(skb->sk);
1814         struct nft_rule_trans *rupd, *tmp;
1815
1816         list_for_each_entry_safe(rupd, tmp, &net->nft.commit_list, list) {
1817                 /* Delete all rules from the dirty list */
1818                 list_del(&rupd->list);
1819
1820                 if (!nft_rule_is_active_next(net, rupd->rule)) {
1821                         nft_rule_clear(net, rupd->rule);
1822                         kfree(rupd);
1823                         continue;
1824                 }
1825
1826                 /* This rule is inactive, get rid of it */
1827                 list_del_rcu(&rupd->rule->list);
1828                 nf_tables_rule_destroy(rupd->rule);
1829                 kfree(rupd);
1830         }
1831         return 0;
1832 }
1833
1834 /*
1835  * Sets
1836  */
1837
1838 static LIST_HEAD(nf_tables_set_ops);
1839
1840 int nft_register_set(struct nft_set_ops *ops)
1841 {
1842         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1843         list_add_tail(&ops->list, &nf_tables_set_ops);
1844         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1845         return 0;
1846 }
1847 EXPORT_SYMBOL_GPL(nft_register_set);
1848
1849 void nft_unregister_set(struct nft_set_ops *ops)
1850 {
1851         nfnl_lock(NFNL_SUBSYS_NFTABLES);
1852         list_del(&ops->list);
1853         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1854 }
1855 EXPORT_SYMBOL_GPL(nft_unregister_set);
1856
1857 static const struct nft_set_ops *nft_select_set_ops(const struct nlattr * const nla[])
1858 {
1859         const struct nft_set_ops *ops;
1860         u32 features;
1861
1862 #ifdef CONFIG_MODULES
1863         if (list_empty(&nf_tables_set_ops)) {
1864                 nfnl_unlock(NFNL_SUBSYS_NFTABLES);
1865                 request_module("nft-set");
1866                 nfnl_lock(NFNL_SUBSYS_NFTABLES);
1867                 if (!list_empty(&nf_tables_set_ops))
1868                         return ERR_PTR(-EAGAIN);
1869         }
1870 #endif
1871         features = 0;
1872         if (nla[NFTA_SET_FLAGS] != NULL) {
1873                 features = ntohl(nla_get_be32(nla[NFTA_SET_FLAGS]));
1874                 features &= NFT_SET_INTERVAL | NFT_SET_MAP;
1875         }
1876
1877         // FIXME: implement selection properly
1878         list_for_each_entry(ops, &nf_tables_set_ops, list) {
1879                 if ((ops->features & features) != features)
1880                         continue;
1881                 if (!try_module_get(ops->owner))
1882                         continue;
1883                 return ops;
1884         }
1885
1886         return ERR_PTR(-EOPNOTSUPP);
1887 }
1888
1889 static const struct nla_policy nft_set_policy[NFTA_SET_MAX + 1] = {
1890         [NFTA_SET_TABLE]                = { .type = NLA_STRING },
1891         [NFTA_SET_NAME]                 = { .type = NLA_STRING },
1892         [NFTA_SET_FLAGS]                = { .type = NLA_U32 },
1893         [NFTA_SET_KEY_TYPE]             = { .type = NLA_U32 },
1894         [NFTA_SET_KEY_LEN]              = { .type = NLA_U32 },
1895         [NFTA_SET_DATA_TYPE]            = { .type = NLA_U32 },
1896         [NFTA_SET_DATA_LEN]             = { .type = NLA_U32 },
1897 };
1898
1899 static int nft_ctx_init_from_setattr(struct nft_ctx *ctx,
1900                                      const struct sk_buff *skb,
1901                                      const struct nlmsghdr *nlh,
1902                                      const struct nlattr * const nla[])
1903 {
1904         struct net *net = sock_net(skb->sk);
1905         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
1906         const struct nft_af_info *afi;
1907         const struct nft_table *table = NULL;
1908
1909         afi = nf_tables_afinfo_lookup(net, nfmsg->nfgen_family, false);
1910         if (IS_ERR(afi))
1911                 return PTR_ERR(afi);
1912
1913         if (nla[NFTA_SET_TABLE] != NULL) {
1914                 table = nf_tables_table_lookup(afi, nla[NFTA_SET_TABLE]);
1915                 if (IS_ERR(table))
1916                         return PTR_ERR(table);
1917         }
1918
1919         nft_ctx_init(ctx, skb, nlh, afi, table, NULL, nla);
1920         return 0;
1921 }
1922
1923 struct nft_set *nf_tables_set_lookup(const struct nft_table *table,
1924                                      const struct nlattr *nla)
1925 {
1926         struct nft_set *set;
1927
1928         if (nla == NULL)
1929                 return ERR_PTR(-EINVAL);
1930
1931         list_for_each_entry(set, &table->sets, list) {
1932                 if (!nla_strcmp(nla, set->name))
1933                         return set;
1934         }
1935         return ERR_PTR(-ENOENT);
1936 }
1937
1938 static int nf_tables_set_alloc_name(struct nft_ctx *ctx, struct nft_set *set,
1939                                     const char *name)
1940 {
1941         const struct nft_set *i;
1942         const char *p;
1943         unsigned long *inuse;
1944         unsigned int n = 0;
1945
1946         p = strnchr(name, IFNAMSIZ, '%');
1947         if (p != NULL) {
1948                 if (p[1] != 'd' || strchr(p + 2, '%'))
1949                         return -EINVAL;
1950
1951                 inuse = (unsigned long *)get_zeroed_page(GFP_KERNEL);
1952                 if (inuse == NULL)
1953                         return -ENOMEM;
1954
1955                 list_for_each_entry(i, &ctx->table->sets, list) {
1956                         if (!sscanf(i->name, name, &n))
1957                                 continue;
1958                         if (n < 0 || n > BITS_PER_LONG * PAGE_SIZE)
1959                                 continue;
1960                         set_bit(n, inuse);
1961                 }
1962
1963                 n = find_first_zero_bit(inuse, BITS_PER_LONG * PAGE_SIZE);
1964                 free_page((unsigned long)inuse);
1965         }
1966
1967         snprintf(set->name, sizeof(set->name), name, n);
1968         list_for_each_entry(i, &ctx->table->sets, list) {
1969                 if (!strcmp(set->name, i->name))
1970                         return -ENFILE;
1971         }
1972         return 0;
1973 }
1974
1975 static int nf_tables_fill_set(struct sk_buff *skb, const struct nft_ctx *ctx,
1976                               const struct nft_set *set, u16 event, u16 flags)
1977 {
1978         struct nfgenmsg *nfmsg;
1979         struct nlmsghdr *nlh;
1980         u32 portid = NETLINK_CB(ctx->skb).portid;
1981         u32 seq = ctx->nlh->nlmsg_seq;
1982
1983         event |= NFNL_SUBSYS_NFTABLES << 8;
1984         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg),
1985                         flags);
1986         if (nlh == NULL)
1987                 goto nla_put_failure;
1988
1989         nfmsg = nlmsg_data(nlh);
1990         nfmsg->nfgen_family     = ctx->afi->family;
1991         nfmsg->version          = NFNETLINK_V0;
1992         nfmsg->res_id           = 0;
1993
1994         if (nla_put_string(skb, NFTA_SET_TABLE, ctx->table->name))
1995                 goto nla_put_failure;
1996         if (nla_put_string(skb, NFTA_SET_NAME, set->name))
1997                 goto nla_put_failure;
1998         if (set->flags != 0)
1999                 if (nla_put_be32(skb, NFTA_SET_FLAGS, htonl(set->flags)))
2000                         goto nla_put_failure;
2001
2002         if (nla_put_be32(skb, NFTA_SET_KEY_TYPE, htonl(set->ktype)))
2003                 goto nla_put_failure;
2004         if (nla_put_be32(skb, NFTA_SET_KEY_LEN, htonl(set->klen)))
2005                 goto nla_put_failure;
2006         if (set->flags & NFT_SET_MAP) {
2007                 if (nla_put_be32(skb, NFTA_SET_DATA_TYPE, htonl(set->dtype)))
2008                         goto nla_put_failure;
2009                 if (nla_put_be32(skb, NFTA_SET_DATA_LEN, htonl(set->dlen)))
2010                         goto nla_put_failure;
2011         }
2012
2013         return nlmsg_end(skb, nlh);
2014
2015 nla_put_failure:
2016         nlmsg_trim(skb, nlh);
2017         return -1;
2018 }
2019
2020 static int nf_tables_set_notify(const struct nft_ctx *ctx,
2021                                 const struct nft_set *set,
2022                                 int event)
2023 {
2024         struct sk_buff *skb;
2025         u32 portid = NETLINK_CB(ctx->skb).portid;
2026         bool report;
2027         int err;
2028
2029         report = nlmsg_report(ctx->nlh);
2030         if (!report && !nfnetlink_has_listeners(ctx->net, NFNLGRP_NFTABLES))
2031                 return 0;
2032
2033         err = -ENOBUFS;
2034         skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
2035         if (skb == NULL)
2036                 goto err;
2037
2038         err = nf_tables_fill_set(skb, ctx, set, event, 0);
2039         if (err < 0) {
2040                 kfree_skb(skb);
2041                 goto err;
2042         }
2043
2044         err = nfnetlink_send(skb, ctx->net, portid, NFNLGRP_NFTABLES, report,
2045                              GFP_KERNEL);
2046 err:
2047         if (err < 0)
2048                 nfnetlink_set_err(ctx->net, portid, NFNLGRP_NFTABLES, err);
2049         return err;
2050 }
2051
2052 static int nf_tables_dump_sets_table(struct nft_ctx *ctx, struct sk_buff *skb,
2053                                      struct netlink_callback *cb)
2054 {
2055         const struct nft_set *set;
2056         unsigned int idx = 0, s_idx = cb->args[0];
2057
2058         if (cb->args[1])
2059                 return skb->len;
2060
2061         list_for_each_entry(set, &ctx->table->sets, list) {
2062                 if (idx < s_idx)
2063                         goto cont;
2064                 if (nf_tables_fill_set(skb, ctx, set, NFT_MSG_NEWSET,
2065                                        NLM_F_MULTI) < 0) {
2066                         cb->args[0] = idx;
2067                         goto done;
2068                 }
2069 cont:
2070                 idx++;
2071         }
2072         cb->args[1] = 1;
2073 done:
2074         return skb->len;
2075 }
2076
2077 static int nf_tables_dump_sets_all(struct nft_ctx *ctx, struct sk_buff *skb,
2078                                    struct netlink_callback *cb)
2079 {
2080         const struct nft_set *set;
2081         unsigned int idx = 0, s_idx = cb->args[0];
2082         struct nft_table *table, *cur_table = (struct nft_table *)cb->args[2];
2083
2084         if (cb->args[1])
2085                 return skb->len;
2086
2087         list_for_each_entry(table, &ctx->afi->tables, list) {
2088                 if (cur_table && cur_table != table)
2089                         continue;
2090
2091                 ctx->table = table;
2092                 list_for_each_entry(set, &ctx->table->sets, list) {
2093                         if (idx < s_idx)
2094                                 goto cont;
2095                         if (nf_tables_fill_set(skb, ctx, set, NFT_MSG_NEWSET,
2096                                                NLM_F_MULTI) < 0) {
2097                                 cb->args[0] = idx;
2098                                 cb->args[2] = (unsigned long) table;
2099                                 goto done;
2100                         }
2101 cont:
2102                         idx++;
2103                 }
2104         }
2105         cb->args[1] = 1;
2106 done:
2107         return skb->len;
2108 }
2109
2110 static int nf_tables_dump_sets(struct sk_buff *skb, struct netlink_callback *cb)
2111 {
2112         const struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh);
2113         struct nlattr *nla[NFTA_SET_MAX + 1];
2114         struct nft_ctx ctx;
2115         int err, ret;
2116
2117         err = nlmsg_parse(cb->nlh, sizeof(*nfmsg), nla, NFTA_SET_MAX,
2118                           nft_set_policy);
2119         if (err < 0)
2120                 return err;
2121
2122         err = nft_ctx_init_from_setattr(&ctx, cb->skb, cb->nlh, (void *)nla);
2123         if (err < 0)
2124                 return err;
2125
2126         if (ctx.table == NULL)
2127                 ret = nf_tables_dump_sets_all(&ctx, skb, cb);
2128         else
2129                 ret = nf_tables_dump_sets_table(&ctx, skb, cb);
2130
2131         return ret;
2132 }
2133
2134 static int nf_tables_getset(struct sock *nlsk, struct sk_buff *skb,
2135                             const struct nlmsghdr *nlh,
2136                             const struct nlattr * const nla[])
2137 {
2138         const struct nft_set *set;
2139         struct nft_ctx ctx;
2140         struct sk_buff *skb2;
2141         int err;
2142
2143         /* Verify existance before starting dump */
2144         err = nft_ctx_init_from_setattr(&ctx, skb, nlh, nla);
2145         if (err < 0)
2146                 return err;
2147
2148         if (nlh->nlmsg_flags & NLM_F_DUMP) {
2149                 struct netlink_dump_control c = {
2150                         .dump = nf_tables_dump_sets,
2151                 };
2152                 return netlink_dump_start(nlsk, skb, nlh, &c);
2153         }
2154
2155         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME]);
2156         if (IS_ERR(set))
2157                 return PTR_ERR(set);
2158
2159         skb2 = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);
2160         if (skb2 == NULL)
2161                 return -ENOMEM;
2162
2163         err = nf_tables_fill_set(skb2, &ctx, set, NFT_MSG_NEWSET, 0);
2164         if (err < 0)
2165                 goto err;
2166
2167         return nlmsg_unicast(nlsk, skb2, NETLINK_CB(skb).portid);
2168
2169 err:
2170         kfree_skb(skb2);
2171         return err;
2172 }
2173
2174 static int nf_tables_newset(struct sock *nlsk, struct sk_buff *skb,
2175                             const struct nlmsghdr *nlh,
2176                             const struct nlattr * const nla[])
2177 {
2178         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2179         const struct nft_set_ops *ops;
2180         const struct nft_af_info *afi;
2181         struct net *net = sock_net(skb->sk);
2182         struct nft_table *table;
2183         struct nft_set *set;
2184         struct nft_ctx ctx;
2185         char name[IFNAMSIZ];
2186         unsigned int size;
2187         bool create;
2188         u32 ktype, klen, dlen, dtype, flags;
2189         int err;
2190
2191         if (nla[NFTA_SET_TABLE] == NULL ||
2192             nla[NFTA_SET_NAME] == NULL ||
2193             nla[NFTA_SET_KEY_LEN] == NULL)
2194                 return -EINVAL;
2195
2196         ktype = NFT_DATA_VALUE;
2197         if (nla[NFTA_SET_KEY_TYPE] != NULL) {
2198                 ktype = ntohl(nla_get_be32(nla[NFTA_SET_KEY_TYPE]));
2199                 if ((ktype & NFT_DATA_RESERVED_MASK) == NFT_DATA_RESERVED_MASK)
2200                         return -EINVAL;
2201         }
2202
2203         klen = ntohl(nla_get_be32(nla[NFTA_SET_KEY_LEN]));
2204         if (klen == 0 || klen > FIELD_SIZEOF(struct nft_data, data))
2205                 return -EINVAL;
2206
2207         flags = 0;
2208         if (nla[NFTA_SET_FLAGS] != NULL) {
2209                 flags = ntohl(nla_get_be32(nla[NFTA_SET_FLAGS]));
2210                 if (flags & ~(NFT_SET_ANONYMOUS | NFT_SET_CONSTANT |
2211                               NFT_SET_INTERVAL | NFT_SET_MAP))
2212                         return -EINVAL;
2213         }
2214
2215         dtype = 0;
2216         dlen  = 0;
2217         if (nla[NFTA_SET_DATA_TYPE] != NULL) {
2218                 if (!(flags & NFT_SET_MAP))
2219                         return -EINVAL;
2220
2221                 dtype = ntohl(nla_get_be32(nla[NFTA_SET_DATA_TYPE]));
2222                 if ((dtype & NFT_DATA_RESERVED_MASK) == NFT_DATA_RESERVED_MASK &&
2223                     dtype != NFT_DATA_VERDICT)
2224                         return -EINVAL;
2225
2226                 if (dtype != NFT_DATA_VERDICT) {
2227                         if (nla[NFTA_SET_DATA_LEN] == NULL)
2228                                 return -EINVAL;
2229                         dlen = ntohl(nla_get_be32(nla[NFTA_SET_DATA_LEN]));
2230                         if (dlen == 0 ||
2231                             dlen > FIELD_SIZEOF(struct nft_data, data))
2232                                 return -EINVAL;
2233                 } else
2234                         dlen = sizeof(struct nft_data);
2235         } else if (flags & NFT_SET_MAP)
2236                 return -EINVAL;
2237
2238         create = nlh->nlmsg_flags & NLM_F_CREATE ? true : false;
2239
2240         afi = nf_tables_afinfo_lookup(net, nfmsg->nfgen_family, create);
2241         if (IS_ERR(afi))
2242                 return PTR_ERR(afi);
2243
2244         table = nf_tables_table_lookup(afi, nla[NFTA_SET_TABLE]);
2245         if (IS_ERR(table))
2246                 return PTR_ERR(table);
2247
2248         nft_ctx_init(&ctx, skb, nlh, afi, table, NULL, nla);
2249
2250         set = nf_tables_set_lookup(table, nla[NFTA_SET_NAME]);
2251         if (IS_ERR(set)) {
2252                 if (PTR_ERR(set) != -ENOENT)
2253                         return PTR_ERR(set);
2254                 set = NULL;
2255         }
2256
2257         if (set != NULL) {
2258                 if (nlh->nlmsg_flags & NLM_F_EXCL)
2259                         return -EEXIST;
2260                 if (nlh->nlmsg_flags & NLM_F_REPLACE)
2261                         return -EOPNOTSUPP;
2262                 return 0;
2263         }
2264
2265         if (!(nlh->nlmsg_flags & NLM_F_CREATE))
2266                 return -ENOENT;
2267
2268         ops = nft_select_set_ops(nla);
2269         if (IS_ERR(ops))
2270                 return PTR_ERR(ops);
2271
2272         size = 0;
2273         if (ops->privsize != NULL)
2274                 size = ops->privsize(nla);
2275
2276         err = -ENOMEM;
2277         set = kzalloc(sizeof(*set) + size, GFP_KERNEL);
2278         if (set == NULL)
2279                 goto err1;
2280
2281         nla_strlcpy(name, nla[NFTA_SET_NAME], sizeof(set->name));
2282         err = nf_tables_set_alloc_name(&ctx, set, name);
2283         if (err < 0)
2284                 goto err2;
2285
2286         INIT_LIST_HEAD(&set->bindings);
2287         set->ops   = ops;
2288         set->ktype = ktype;
2289         set->klen  = klen;
2290         set->dtype = dtype;
2291         set->dlen  = dlen;
2292         set->flags = flags;
2293
2294         err = ops->init(set, nla);
2295         if (err < 0)
2296                 goto err2;
2297
2298         list_add_tail(&set->list, &table->sets);
2299         nf_tables_set_notify(&ctx, set, NFT_MSG_NEWSET);
2300         return 0;
2301
2302 err2:
2303         kfree(set);
2304 err1:
2305         module_put(ops->owner);
2306         return err;
2307 }
2308
2309 static void nf_tables_set_destroy(const struct nft_ctx *ctx, struct nft_set *set)
2310 {
2311         list_del(&set->list);
2312         if (!(set->flags & NFT_SET_ANONYMOUS))
2313                 nf_tables_set_notify(ctx, set, NFT_MSG_DELSET);
2314
2315         set->ops->destroy(set);
2316         module_put(set->ops->owner);
2317         kfree(set);
2318 }
2319
2320 static int nf_tables_delset(struct sock *nlsk, struct sk_buff *skb,
2321                             const struct nlmsghdr *nlh,
2322                             const struct nlattr * const nla[])
2323 {
2324         struct nft_set *set;
2325         struct nft_ctx ctx;
2326         int err;
2327
2328         if (nla[NFTA_SET_TABLE] == NULL)
2329                 return -EINVAL;
2330
2331         err = nft_ctx_init_from_setattr(&ctx, skb, nlh, nla);
2332         if (err < 0)
2333                 return err;
2334
2335         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_NAME]);
2336         if (IS_ERR(set))
2337                 return PTR_ERR(set);
2338         if (!list_empty(&set->bindings))
2339                 return -EBUSY;
2340
2341         nf_tables_set_destroy(&ctx, set);
2342         return 0;
2343 }
2344
2345 static int nf_tables_bind_check_setelem(const struct nft_ctx *ctx,
2346                                         const struct nft_set *set,
2347                                         const struct nft_set_iter *iter,
2348                                         const struct nft_set_elem *elem)
2349 {
2350         enum nft_registers dreg;
2351
2352         dreg = nft_type_to_reg(set->dtype);
2353         return nft_validate_data_load(ctx, dreg, &elem->data, set->dtype);
2354 }
2355
2356 int nf_tables_bind_set(const struct nft_ctx *ctx, struct nft_set *set,
2357                        struct nft_set_binding *binding)
2358 {
2359         struct nft_set_binding *i;
2360         struct nft_set_iter iter;
2361
2362         if (!list_empty(&set->bindings) && set->flags & NFT_SET_ANONYMOUS)
2363                 return -EBUSY;
2364
2365         if (set->flags & NFT_SET_MAP) {
2366                 /* If the set is already bound to the same chain all
2367                  * jumps are already validated for that chain.
2368                  */
2369                 list_for_each_entry(i, &set->bindings, list) {
2370                         if (i->chain == binding->chain)
2371                                 goto bind;
2372                 }
2373
2374                 iter.skip       = 0;
2375                 iter.count      = 0;
2376                 iter.err        = 0;
2377                 iter.fn         = nf_tables_bind_check_setelem;
2378
2379                 set->ops->walk(ctx, set, &iter);
2380                 if (iter.err < 0) {
2381                         /* Destroy anonymous sets if binding fails */
2382                         if (set->flags & NFT_SET_ANONYMOUS)
2383                                 nf_tables_set_destroy(ctx, set);
2384
2385                         return iter.err;
2386                 }
2387         }
2388 bind:
2389         binding->chain = ctx->chain;
2390         list_add_tail(&binding->list, &set->bindings);
2391         return 0;
2392 }
2393
2394 void nf_tables_unbind_set(const struct nft_ctx *ctx, struct nft_set *set,
2395                           struct nft_set_binding *binding)
2396 {
2397         list_del(&binding->list);
2398
2399         if (list_empty(&set->bindings) && set->flags & NFT_SET_ANONYMOUS)
2400                 nf_tables_set_destroy(ctx, set);
2401 }
2402
2403 /*
2404  * Set elements
2405  */
2406
2407 static const struct nla_policy nft_set_elem_policy[NFTA_SET_ELEM_MAX + 1] = {
2408         [NFTA_SET_ELEM_KEY]             = { .type = NLA_NESTED },
2409         [NFTA_SET_ELEM_DATA]            = { .type = NLA_NESTED },
2410         [NFTA_SET_ELEM_FLAGS]           = { .type = NLA_U32 },
2411 };
2412
2413 static const struct nla_policy nft_set_elem_list_policy[NFTA_SET_ELEM_LIST_MAX + 1] = {
2414         [NFTA_SET_ELEM_LIST_TABLE]      = { .type = NLA_STRING },
2415         [NFTA_SET_ELEM_LIST_SET]        = { .type = NLA_STRING },
2416         [NFTA_SET_ELEM_LIST_ELEMENTS]   = { .type = NLA_NESTED },
2417 };
2418
2419 static int nft_ctx_init_from_elemattr(struct nft_ctx *ctx,
2420                                       const struct sk_buff *skb,
2421                                       const struct nlmsghdr *nlh,
2422                                       const struct nlattr * const nla[])
2423 {
2424         const struct nfgenmsg *nfmsg = nlmsg_data(nlh);
2425         const struct nft_af_info *afi;
2426         const struct nft_table *table;
2427         struct net *net = sock_net(skb->sk);
2428
2429         afi = nf_tables_afinfo_lookup(net, nfmsg->nfgen_family, false);
2430         if (IS_ERR(afi))
2431                 return PTR_ERR(afi);
2432
2433         table = nf_tables_table_lookup(afi, nla[NFTA_SET_ELEM_LIST_TABLE]);
2434         if (IS_ERR(table))
2435                 return PTR_ERR(table);
2436
2437         nft_ctx_init(ctx, skb, nlh, afi, table, NULL, nla);
2438         return 0;
2439 }
2440
2441 static int nf_tables_fill_setelem(struct sk_buff *skb,
2442                                   const struct nft_set *set,
2443                                   const struct nft_set_elem *elem)
2444 {
2445         unsigned char *b = skb_tail_pointer(skb);
2446         struct nlattr *nest;
2447
2448         nest = nla_nest_start(skb, NFTA_LIST_ELEM);
2449         if (nest == NULL)
2450                 goto nla_put_failure;
2451
2452         if (nft_data_dump(skb, NFTA_SET_ELEM_KEY, &elem->key, NFT_DATA_VALUE,
2453                           set->klen) < 0)
2454                 goto nla_put_failure;
2455
2456         if (set->flags & NFT_SET_MAP &&
2457             !(elem->flags & NFT_SET_ELEM_INTERVAL_END) &&
2458             nft_data_dump(skb, NFTA_SET_ELEM_DATA, &elem->data,
2459                           set->dtype == NFT_DATA_VERDICT ? NFT_DATA_VERDICT : NFT_DATA_VALUE,
2460                           set->dlen) < 0)
2461                 goto nla_put_failure;
2462
2463         if (elem->flags != 0)
2464                 if (nla_put_be32(skb, NFTA_SET_ELEM_FLAGS, htonl(elem->flags)))
2465                         goto nla_put_failure;
2466
2467         nla_nest_end(skb, nest);
2468         return 0;
2469
2470 nla_put_failure:
2471         nlmsg_trim(skb, b);
2472         return -EMSGSIZE;
2473 }
2474
2475 struct nft_set_dump_args {
2476         const struct netlink_callback   *cb;
2477         struct nft_set_iter             iter;
2478         struct sk_buff                  *skb;
2479 };
2480
2481 static int nf_tables_dump_setelem(const struct nft_ctx *ctx,
2482                                   const struct nft_set *set,
2483                                   const struct nft_set_iter *iter,
2484                                   const struct nft_set_elem *elem)
2485 {
2486         struct nft_set_dump_args *args;
2487
2488         args = container_of(iter, struct nft_set_dump_args, iter);
2489         return nf_tables_fill_setelem(args->skb, set, elem);
2490 }
2491
2492 static int nf_tables_dump_set(struct sk_buff *skb, struct netlink_callback *cb)
2493 {
2494         const struct nft_set *set;
2495         struct nft_set_dump_args args;
2496         struct nft_ctx ctx;
2497         struct nlattr *nla[NFTA_SET_ELEM_LIST_MAX + 1];
2498         struct nfgenmsg *nfmsg;
2499         struct nlmsghdr *nlh;
2500         struct nlattr *nest;
2501         u32 portid, seq;
2502         int event, err;
2503
2504         nfmsg = nlmsg_data(cb->nlh);
2505         err = nlmsg_parse(cb->nlh, sizeof(*nfmsg), nla, NFTA_SET_ELEM_LIST_MAX,
2506                           nft_set_elem_list_policy);
2507         if (err < 0)
2508                 return err;
2509
2510         err = nft_ctx_init_from_elemattr(&ctx, cb->skb, cb->nlh, (void *)nla);
2511         if (err < 0)
2512                 return err;
2513
2514         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET]);
2515         if (IS_ERR(set))
2516                 return PTR_ERR(set);
2517
2518         event  = NFT_MSG_NEWSETELEM;
2519         event |= NFNL_SUBSYS_NFTABLES << 8;
2520         portid = NETLINK_CB(cb->skb).portid;
2521         seq    = cb->nlh->nlmsg_seq;
2522
2523         nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct nfgenmsg),
2524                         NLM_F_MULTI);
2525         if (nlh == NULL)
2526                 goto nla_put_failure;
2527
2528         nfmsg = nlmsg_data(nlh);
2529         nfmsg->nfgen_family = NFPROTO_UNSPEC;
2530         nfmsg->version      = NFNETLINK_V0;
2531         nfmsg->res_id       = 0;
2532
2533         if (nla_put_string(skb, NFTA_SET_ELEM_LIST_TABLE, ctx.table->name))
2534                 goto nla_put_failure;
2535         if (nla_put_string(skb, NFTA_SET_ELEM_LIST_SET, set->name))
2536                 goto nla_put_failure;
2537
2538         nest = nla_nest_start(skb, NFTA_SET_ELEM_LIST_ELEMENTS);
2539         if (nest == NULL)
2540                 goto nla_put_failure;
2541
2542         args.cb         = cb;
2543         args.skb        = skb;
2544         args.iter.skip  = cb->args[0];
2545         args.iter.count = 0;
2546         args.iter.err   = 0;
2547         args.iter.fn    = nf_tables_dump_setelem;
2548         set->ops->walk(&ctx, set, &args.iter);
2549
2550         nla_nest_end(skb, nest);
2551         nlmsg_end(skb, nlh);
2552
2553         if (args.iter.err && args.iter.err != -EMSGSIZE)
2554                 return args.iter.err;
2555         if (args.iter.count == cb->args[0])
2556                 return 0;
2557
2558         cb->args[0] = args.iter.count;
2559         return skb->len;
2560
2561 nla_put_failure:
2562         return -ENOSPC;
2563 }
2564
2565 static int nf_tables_getsetelem(struct sock *nlsk, struct sk_buff *skb,
2566                                 const struct nlmsghdr *nlh,
2567                                 const struct nlattr * const nla[])
2568 {
2569         const struct nft_set *set;
2570         struct nft_ctx ctx;
2571         int err;
2572
2573         err = nft_ctx_init_from_elemattr(&ctx, skb, nlh, nla);
2574         if (err < 0)
2575                 return err;
2576
2577         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET]);
2578         if (IS_ERR(set))
2579                 return PTR_ERR(set);
2580
2581         if (nlh->nlmsg_flags & NLM_F_DUMP) {
2582                 struct netlink_dump_control c = {
2583                         .dump = nf_tables_dump_set,
2584                 };
2585                 return netlink_dump_start(nlsk, skb, nlh, &c);
2586         }
2587         return -EOPNOTSUPP;
2588 }
2589
2590 static int nft_add_set_elem(const struct nft_ctx *ctx, struct nft_set *set,
2591                             const struct nlattr *attr)
2592 {
2593         struct nlattr *nla[NFTA_SET_ELEM_MAX + 1];
2594         struct nft_data_desc d1, d2;
2595         struct nft_set_elem elem;
2596         struct nft_set_binding *binding;
2597         enum nft_registers dreg;
2598         int err;
2599
2600         err = nla_parse_nested(nla, NFTA_SET_ELEM_MAX, attr,
2601                                nft_set_elem_policy);
2602         if (err < 0)
2603                 return err;
2604
2605         if (nla[NFTA_SET_ELEM_KEY] == NULL)
2606                 return -EINVAL;
2607
2608         elem.flags = 0;
2609         if (nla[NFTA_SET_ELEM_FLAGS] != NULL) {
2610                 elem.flags = ntohl(nla_get_be32(nla[NFTA_SET_ELEM_FLAGS]));
2611                 if (elem.flags & ~NFT_SET_ELEM_INTERVAL_END)
2612                         return -EINVAL;
2613         }
2614
2615         if (set->flags & NFT_SET_MAP) {
2616                 if (nla[NFTA_SET_ELEM_DATA] == NULL &&
2617                     !(elem.flags & NFT_SET_ELEM_INTERVAL_END))
2618                         return -EINVAL;
2619         } else {
2620                 if (nla[NFTA_SET_ELEM_DATA] != NULL)
2621                         return -EINVAL;
2622         }
2623
2624         err = nft_data_init(ctx, &elem.key, &d1, nla[NFTA_SET_ELEM_KEY]);
2625         if (err < 0)
2626                 goto err1;
2627         err = -EINVAL;
2628         if (d1.type != NFT_DATA_VALUE || d1.len != set->klen)
2629                 goto err2;
2630
2631         err = -EEXIST;
2632         if (set->ops->get(set, &elem) == 0)
2633                 goto err2;
2634
2635         if (nla[NFTA_SET_ELEM_DATA] != NULL) {
2636                 err = nft_data_init(ctx, &elem.data, &d2, nla[NFTA_SET_ELEM_DATA]);
2637                 if (err < 0)
2638                         goto err2;
2639
2640                 err = -EINVAL;
2641                 if (set->dtype != NFT_DATA_VERDICT && d2.len != set->dlen)
2642                         goto err3;
2643
2644                 dreg = nft_type_to_reg(set->dtype);
2645                 list_for_each_entry(binding, &set->bindings, list) {
2646                         struct nft_ctx bind_ctx = {
2647                                 .afi    = ctx->afi,
2648                                 .table  = ctx->table,
2649                                 .chain  = binding->chain,
2650                         };
2651
2652                         err = nft_validate_data_load(&bind_ctx, dreg,
2653                                                      &elem.data, d2.type);
2654                         if (err < 0)
2655                                 goto err3;
2656                 }
2657         }
2658
2659         err = set->ops->insert(set, &elem);
2660         if (err < 0)
2661                 goto err3;
2662
2663         return 0;
2664
2665 err3:
2666         if (nla[NFTA_SET_ELEM_DATA] != NULL)
2667                 nft_data_uninit(&elem.data, d2.type);
2668 err2:
2669         nft_data_uninit(&elem.key, d1.type);
2670 err1:
2671         return err;
2672 }
2673
2674 static int nf_tables_newsetelem(struct sock *nlsk, struct sk_buff *skb,
2675                                 const struct nlmsghdr *nlh,
2676                                 const struct nlattr * const nla[])
2677 {
2678         const struct nlattr *attr;
2679         struct nft_set *set;
2680         struct nft_ctx ctx;
2681         int rem, err;
2682
2683         err = nft_ctx_init_from_elemattr(&ctx, skb, nlh, nla);
2684         if (err < 0)
2685                 return err;
2686
2687         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET]);
2688         if (IS_ERR(set))
2689                 return PTR_ERR(set);
2690         if (!list_empty(&set->bindings) && set->flags & NFT_SET_CONSTANT)
2691                 return -EBUSY;
2692
2693         nla_for_each_nested(attr, nla[NFTA_SET_ELEM_LIST_ELEMENTS], rem) {
2694                 err = nft_add_set_elem(&ctx, set, attr);
2695                 if (err < 0)
2696                         return err;
2697         }
2698         return 0;
2699 }
2700
2701 static int nft_del_setelem(const struct nft_ctx *ctx, struct nft_set *set,
2702                            const struct nlattr *attr)
2703 {
2704         struct nlattr *nla[NFTA_SET_ELEM_MAX + 1];
2705         struct nft_data_desc desc;
2706         struct nft_set_elem elem;
2707         int err;
2708
2709         err = nla_parse_nested(nla, NFTA_SET_ELEM_MAX, attr,
2710                                nft_set_elem_policy);
2711         if (err < 0)
2712                 goto err1;
2713
2714         err = -EINVAL;
2715         if (nla[NFTA_SET_ELEM_KEY] == NULL)
2716                 goto err1;
2717
2718         err = nft_data_init(ctx, &elem.key, &desc, nla[NFTA_SET_ELEM_KEY]);
2719         if (err < 0)
2720                 goto err1;
2721
2722         err = -EINVAL;
2723         if (desc.type != NFT_DATA_VALUE || desc.len != set->klen)
2724                 goto err2;
2725
2726         err = set->ops->get(set, &elem);
2727         if (err < 0)
2728                 goto err2;
2729
2730         set->ops->remove(set, &elem);
2731
2732         nft_data_uninit(&elem.key, NFT_DATA_VALUE);
2733         if (set->flags & NFT_SET_MAP)
2734                 nft_data_uninit(&elem.data, set->dtype);
2735
2736 err2:
2737         nft_data_uninit(&elem.key, desc.type);
2738 err1:
2739         return err;
2740 }
2741
2742 static int nf_tables_delsetelem(struct sock *nlsk, struct sk_buff *skb,
2743                                 const struct nlmsghdr *nlh,
2744                                 const struct nlattr * const nla[])
2745 {
2746         const struct nlattr *attr;
2747         struct nft_set *set;
2748         struct nft_ctx ctx;
2749         int rem, err;
2750
2751         err = nft_ctx_init_from_elemattr(&ctx, skb, nlh, nla);
2752         if (err < 0)
2753                 return err;
2754
2755         set = nf_tables_set_lookup(ctx.table, nla[NFTA_SET_ELEM_LIST_SET]);
2756         if (IS_ERR(set))
2757                 return PTR_ERR(set);
2758         if (!list_empty(&set->bindings) && set->flags & NFT_SET_CONSTANT)
2759                 return -EBUSY;
2760
2761         nla_for_each_nested(attr, nla[NFTA_SET_ELEM_LIST_ELEMENTS], rem) {
2762                 err = nft_del_setelem(&ctx, set, attr);
2763                 if (err < 0)
2764                         return err;
2765         }
2766         return 0;
2767 }
2768
2769 static const struct nfnl_callback nf_tables_cb[NFT_MSG_MAX] = {
2770         [NFT_MSG_NEWTABLE] = {
2771                 .call           = nf_tables_newtable,
2772                 .attr_count     = NFTA_TABLE_MAX,
2773                 .policy         = nft_table_policy,
2774         },
2775         [NFT_MSG_GETTABLE] = {
2776                 .call           = nf_tables_gettable,
2777                 .attr_count     = NFTA_TABLE_MAX,
2778                 .policy         = nft_table_policy,
2779         },
2780         [NFT_MSG_DELTABLE] = {
2781                 .call           = nf_tables_deltable,
2782                 .attr_count     = NFTA_TABLE_MAX,
2783                 .policy         = nft_table_policy,
2784         },
2785         [NFT_MSG_NEWCHAIN] = {
2786                 .call           = nf_tables_newchain,
2787                 .attr_count     = NFTA_CHAIN_MAX,
2788                 .policy         = nft_chain_policy,
2789         },
2790         [NFT_MSG_GETCHAIN] = {
2791                 .call           = nf_tables_getchain,
2792                 .attr_count     = NFTA_CHAIN_MAX,
2793                 .policy         = nft_chain_policy,
2794         },
2795         [NFT_MSG_DELCHAIN] = {
2796                 .call           = nf_tables_delchain,
2797                 .attr_count     = NFTA_CHAIN_MAX,
2798                 .policy         = nft_chain_policy,
2799         },
2800         [NFT_MSG_NEWRULE] = {
2801                 .call_batch     = nf_tables_newrule,
2802                 .attr_count     = NFTA_RULE_MAX,
2803                 .policy         = nft_rule_policy,
2804         },
2805         [NFT_MSG_GETRULE] = {
2806                 .call           = nf_tables_getrule,
2807                 .attr_count     = NFTA_RULE_MAX,
2808                 .policy         = nft_rule_policy,
2809         },
2810         [NFT_MSG_DELRULE] = {
2811                 .call_batch     = nf_tables_delrule,
2812                 .attr_count     = NFTA_RULE_MAX,
2813                 .policy         = nft_rule_policy,
2814         },
2815         [NFT_MSG_NEWSET] = {
2816                 .call           = nf_tables_newset,
2817                 .attr_count     = NFTA_SET_MAX,
2818                 .policy         = nft_set_policy,
2819         },
2820         [NFT_MSG_GETSET] = {
2821                 .call           = nf_tables_getset,
2822                 .attr_count     = NFTA_SET_MAX,
2823                 .policy         = nft_set_policy,
2824         },
2825         [NFT_MSG_DELSET] = {
2826                 .call           = nf_tables_delset,
2827                 .attr_count     = NFTA_SET_MAX,
2828                 .policy         = nft_set_policy,
2829         },
2830         [NFT_MSG_NEWSETELEM] = {
2831                 .call           = nf_tables_newsetelem,
2832                 .attr_count     = NFTA_SET_ELEM_LIST_MAX,
2833                 .policy         = nft_set_elem_list_policy,
2834         },
2835         [NFT_MSG_GETSETELEM] = {
2836                 .call           = nf_tables_getsetelem,
2837                 .attr_count     = NFTA_SET_ELEM_LIST_MAX,
2838                 .policy         = nft_set_elem_list_policy,
2839         },
2840         [NFT_MSG_DELSETELEM] = {
2841                 .call           = nf_tables_delsetelem,
2842                 .attr_count     = NFTA_SET_ELEM_LIST_MAX,
2843                 .policy         = nft_set_elem_list_policy,
2844         },
2845 };
2846
2847 static const struct nfnetlink_subsystem nf_tables_subsys = {
2848         .name           = "nf_tables",
2849         .subsys_id      = NFNL_SUBSYS_NFTABLES,
2850         .cb_count       = NFT_MSG_MAX,
2851         .cb             = nf_tables_cb,
2852         .commit         = nf_tables_commit,
2853         .abort          = nf_tables_abort,
2854 };
2855
2856 /*
2857  * Loop detection - walk through the ruleset beginning at the destination chain
2858  * of a new jump until either the source chain is reached (loop) or all
2859  * reachable chains have been traversed.
2860  *
2861  * The loop check is performed whenever a new jump verdict is added to an
2862  * expression or verdict map or a verdict map is bound to a new chain.
2863  */
2864
2865 static int nf_tables_check_loops(const struct nft_ctx *ctx,
2866                                  const struct nft_chain *chain);
2867
2868 static int nf_tables_loop_check_setelem(const struct nft_ctx *ctx,
2869                                         const struct nft_set *set,
2870                                         const struct nft_set_iter *iter,
2871                                         const struct nft_set_elem *elem)
2872 {
2873         switch (elem->data.verdict) {
2874         case NFT_JUMP:
2875         case NFT_GOTO:
2876                 return nf_tables_check_loops(ctx, elem->data.chain);
2877         default:
2878                 return 0;
2879         }
2880 }
2881
2882 static int nf_tables_check_loops(const struct nft_ctx *ctx,
2883                                  const struct nft_chain *chain)
2884 {
2885         const struct nft_rule *rule;
2886         const struct nft_expr *expr, *last;
2887         const struct nft_set *set;
2888         struct nft_set_binding *binding;
2889         struct nft_set_iter iter;
2890
2891         if (ctx->chain == chain)
2892                 return -ELOOP;
2893
2894         list_for_each_entry(rule, &chain->rules, list) {
2895                 nft_rule_for_each_expr(expr, last, rule) {
2896                         const struct nft_data *data = NULL;
2897                         int err;
2898
2899                         if (!expr->ops->validate)
2900                                 continue;
2901
2902                         err = expr->ops->validate(ctx, expr, &data);
2903                         if (err < 0)
2904                                 return err;
2905
2906                         if (data == NULL)
2907                                 continue;
2908
2909                         switch (data->verdict) {
2910                         case NFT_JUMP:
2911                         case NFT_GOTO:
2912                                 err = nf_tables_check_loops(ctx, data->chain);
2913                                 if (err < 0)
2914                                         return err;
2915                         default:
2916                                 break;
2917                         }
2918                 }
2919         }
2920
2921         list_for_each_entry(set, &ctx->table->sets, list) {
2922                 if (!(set->flags & NFT_SET_MAP) ||
2923                     set->dtype != NFT_DATA_VERDICT)
2924                         continue;
2925
2926                 list_for_each_entry(binding, &set->bindings, list) {
2927                         if (binding->chain != chain)
2928                                 continue;
2929
2930                         iter.skip       = 0;
2931                         iter.count      = 0;
2932                         iter.err        = 0;
2933                         iter.fn         = nf_tables_loop_check_setelem;
2934
2935                         set->ops->walk(ctx, set, &iter);
2936                         if (iter.err < 0)
2937                                 return iter.err;
2938                 }
2939         }
2940
2941         return 0;
2942 }
2943
2944 /**
2945  *      nft_validate_input_register - validate an expressions' input register
2946  *
2947  *      @reg: the register number
2948  *
2949  *      Validate that the input register is one of the general purpose
2950  *      registers.
2951  */
2952 int nft_validate_input_register(enum nft_registers reg)
2953 {
2954         if (reg <= NFT_REG_VERDICT)
2955                 return -EINVAL;
2956         if (reg > NFT_REG_MAX)
2957                 return -ERANGE;
2958         return 0;
2959 }
2960 EXPORT_SYMBOL_GPL(nft_validate_input_register);
2961
2962 /**
2963  *      nft_validate_output_register - validate an expressions' output register
2964  *
2965  *      @reg: the register number
2966  *
2967  *      Validate that the output register is one of the general purpose
2968  *      registers or the verdict register.
2969  */
2970 int nft_validate_output_register(enum nft_registers reg)
2971 {
2972         if (reg < NFT_REG_VERDICT)
2973                 return -EINVAL;
2974         if (reg > NFT_REG_MAX)
2975                 return -ERANGE;
2976         return 0;
2977 }
2978 EXPORT_SYMBOL_GPL(nft_validate_output_register);
2979
2980 /**
2981  *      nft_validate_data_load - validate an expressions' data load
2982  *
2983  *      @ctx: context of the expression performing the load
2984  *      @reg: the destination register number
2985  *      @data: the data to load
2986  *      @type: the data type
2987  *
2988  *      Validate that a data load uses the appropriate data type for
2989  *      the destination register. A value of NULL for the data means
2990  *      that its runtime gathered data, which is always of type
2991  *      NFT_DATA_VALUE.
2992  */
2993 int nft_validate_data_load(const struct nft_ctx *ctx, enum nft_registers reg,
2994                            const struct nft_data *data,
2995                            enum nft_data_types type)
2996 {
2997         int err;
2998
2999         switch (reg) {
3000         case NFT_REG_VERDICT:
3001                 if (data == NULL || type != NFT_DATA_VERDICT)
3002                         return -EINVAL;
3003
3004                 if (data->verdict == NFT_GOTO || data->verdict == NFT_JUMP) {
3005                         err = nf_tables_check_loops(ctx, data->chain);
3006                         if (err < 0)
3007                                 return err;
3008
3009                         if (ctx->chain->level + 1 > data->chain->level) {
3010                                 if (ctx->chain->level + 1 == NFT_JUMP_STACK_SIZE)
3011                                         return -EMLINK;
3012                                 data->chain->level = ctx->chain->level + 1;
3013                         }
3014                 }
3015
3016                 return 0;
3017         default:
3018                 if (data != NULL && type != NFT_DATA_VALUE)
3019                         return -EINVAL;
3020                 return 0;
3021         }
3022 }
3023 EXPORT_SYMBOL_GPL(nft_validate_data_load);
3024
3025 static const struct nla_policy nft_verdict_policy[NFTA_VERDICT_MAX + 1] = {
3026         [NFTA_VERDICT_CODE]     = { .type = NLA_U32 },
3027         [NFTA_VERDICT_CHAIN]    = { .type = NLA_STRING,
3028                                     .len = NFT_CHAIN_MAXNAMELEN - 1 },
3029 };
3030
3031 static int nft_verdict_init(const struct nft_ctx *ctx, struct nft_data *data,
3032                             struct nft_data_desc *desc, const struct nlattr *nla)
3033 {
3034         struct nlattr *tb[NFTA_VERDICT_MAX + 1];
3035         struct nft_chain *chain;
3036         int err;
3037
3038         err = nla_parse_nested(tb, NFTA_VERDICT_MAX, nla, nft_verdict_policy);
3039         if (err < 0)
3040                 return err;
3041
3042         if (!tb[NFTA_VERDICT_CODE])
3043                 return -EINVAL;
3044         data->verdict = ntohl(nla_get_be32(tb[NFTA_VERDICT_CODE]));
3045
3046         switch (data->verdict) {
3047         case NF_ACCEPT:
3048         case NF_DROP:
3049         case NF_QUEUE:
3050         case NFT_CONTINUE:
3051         case NFT_BREAK:
3052         case NFT_RETURN:
3053                 desc->len = sizeof(data->verdict);
3054                 break;
3055         case NFT_JUMP:
3056         case NFT_GOTO:
3057                 if (!tb[NFTA_VERDICT_CHAIN])
3058                         return -EINVAL;
3059                 chain = nf_tables_chain_lookup(ctx->table,
3060                                                tb[NFTA_VERDICT_CHAIN]);
3061                 if (IS_ERR(chain))
3062                         return PTR_ERR(chain);
3063                 if (chain->flags & NFT_BASE_CHAIN)
3064                         return -EOPNOTSUPP;
3065
3066                 chain->use++;
3067                 data->chain = chain;
3068                 desc->len = sizeof(data);
3069                 break;
3070         default:
3071                 return -EINVAL;
3072         }
3073
3074         desc->type = NFT_DATA_VERDICT;
3075         return 0;
3076 }
3077
3078 static void nft_verdict_uninit(const struct nft_data *data)
3079 {
3080         switch (data->verdict) {
3081         case NFT_JUMP:
3082         case NFT_GOTO:
3083                 data->chain->use--;
3084                 break;
3085         }
3086 }
3087
3088 static int nft_verdict_dump(struct sk_buff *skb, const struct nft_data *data)
3089 {
3090         struct nlattr *nest;
3091
3092         nest = nla_nest_start(skb, NFTA_DATA_VERDICT);
3093         if (!nest)
3094                 goto nla_put_failure;
3095
3096         if (nla_put_be32(skb, NFTA_VERDICT_CODE, htonl(data->verdict)))
3097                 goto nla_put_failure;
3098
3099         switch (data->verdict) {
3100         case NFT_JUMP:
3101         case NFT_GOTO:
3102                 if (nla_put_string(skb, NFTA_VERDICT_CHAIN, data->chain->name))
3103                         goto nla_put_failure;
3104         }
3105         nla_nest_end(skb, nest);
3106         return 0;
3107
3108 nla_put_failure:
3109         return -1;
3110 }
3111
3112 static int nft_value_init(const struct nft_ctx *ctx, struct nft_data *data,
3113                           struct nft_data_desc *desc, const struct nlattr *nla)
3114 {
3115         unsigned int len;
3116
3117         len = nla_len(nla);
3118         if (len == 0)
3119                 return -EINVAL;
3120         if (len > sizeof(data->data))
3121                 return -EOVERFLOW;
3122
3123         nla_memcpy(data->data, nla, sizeof(data->data));
3124         desc->type = NFT_DATA_VALUE;
3125         desc->len  = len;
3126         return 0;
3127 }
3128
3129 static int nft_value_dump(struct sk_buff *skb, const struct nft_data *data,
3130                           unsigned int len)
3131 {
3132         return nla_put(skb, NFTA_DATA_VALUE, len, data->data);
3133 }
3134
3135 static const struct nla_policy nft_data_policy[NFTA_DATA_MAX + 1] = {
3136         [NFTA_DATA_VALUE]       = { .type = NLA_BINARY,
3137                                     .len  = FIELD_SIZEOF(struct nft_data, data) },
3138         [NFTA_DATA_VERDICT]     = { .type = NLA_NESTED },
3139 };
3140
3141 /**
3142  *      nft_data_init - parse nf_tables data netlink attributes
3143  *
3144  *      @ctx: context of the expression using the data
3145  *      @data: destination struct nft_data
3146  *      @desc: data description
3147  *      @nla: netlink attribute containing data
3148  *
3149  *      Parse the netlink data attributes and initialize a struct nft_data.
3150  *      The type and length of data are returned in the data description.
3151  *
3152  *      The caller can indicate that it only wants to accept data of type
3153  *      NFT_DATA_VALUE by passing NULL for the ctx argument.
3154  */
3155 int nft_data_init(const struct nft_ctx *ctx, struct nft_data *data,
3156                   struct nft_data_desc *desc, const struct nlattr *nla)
3157 {
3158         struct nlattr *tb[NFTA_DATA_MAX + 1];
3159         int err;
3160
3161         err = nla_parse_nested(tb, NFTA_DATA_MAX, nla, nft_data_policy);
3162         if (err < 0)
3163                 return err;
3164
3165         if (tb[NFTA_DATA_VALUE])
3166                 return nft_value_init(ctx, data, desc, tb[NFTA_DATA_VALUE]);
3167         if (tb[NFTA_DATA_VERDICT] && ctx != NULL)
3168                 return nft_verdict_init(ctx, data, desc, tb[NFTA_DATA_VERDICT]);
3169         return -EINVAL;
3170 }
3171 EXPORT_SYMBOL_GPL(nft_data_init);
3172
3173 /**
3174  *      nft_data_uninit - release a nft_data item
3175  *
3176  *      @data: struct nft_data to release
3177  *      @type: type of data
3178  *
3179  *      Release a nft_data item. NFT_DATA_VALUE types can be silently discarded,
3180  *      all others need to be released by calling this function.
3181  */
3182 void nft_data_uninit(const struct nft_data *data, enum nft_data_types type)
3183 {
3184         switch (type) {
3185         case NFT_DATA_VALUE:
3186                 return;
3187         case NFT_DATA_VERDICT:
3188                 return nft_verdict_uninit(data);
3189         default:
3190                 WARN_ON(1);
3191         }
3192 }
3193 EXPORT_SYMBOL_GPL(nft_data_uninit);
3194
3195 int nft_data_dump(struct sk_buff *skb, int attr, const struct nft_data *data,
3196                   enum nft_data_types type, unsigned int len)
3197 {
3198         struct nlattr *nest;
3199         int err;
3200
3201         nest = nla_nest_start(skb, attr);
3202         if (nest == NULL)
3203                 return -1;
3204
3205         switch (type) {
3206         case NFT_DATA_VALUE:
3207                 err = nft_value_dump(skb, data, len);
3208                 break;
3209         case NFT_DATA_VERDICT:
3210                 err = nft_verdict_dump(skb, data);
3211                 break;
3212         default:
3213                 err = -EINVAL;
3214                 WARN_ON(1);
3215         }
3216
3217         nla_nest_end(skb, nest);
3218         return err;
3219 }
3220 EXPORT_SYMBOL_GPL(nft_data_dump);
3221
3222 static int nf_tables_init_net(struct net *net)
3223 {
3224         INIT_LIST_HEAD(&net->nft.af_info);
3225         INIT_LIST_HEAD(&net->nft.commit_list);
3226         return 0;
3227 }
3228
3229 static struct pernet_operations nf_tables_net_ops = {
3230         .init   = nf_tables_init_net,
3231 };
3232
3233 static int __init nf_tables_module_init(void)
3234 {
3235         int err;
3236
3237         info = kmalloc(sizeof(struct nft_expr_info) * NFT_RULE_MAXEXPRS,
3238                        GFP_KERNEL);
3239         if (info == NULL) {
3240                 err = -ENOMEM;
3241                 goto err1;
3242         }
3243
3244         err = nf_tables_core_module_init();
3245         if (err < 0)
3246                 goto err2;
3247
3248         err = nfnetlink_subsys_register(&nf_tables_subsys);
3249         if (err < 0)
3250                 goto err3;
3251
3252         pr_info("nf_tables: (c) 2007-2009 Patrick McHardy <kaber@trash.net>\n");
3253         return register_pernet_subsys(&nf_tables_net_ops);
3254 err3:
3255         nf_tables_core_module_exit();
3256 err2:
3257         kfree(info);
3258 err1:
3259         return err;
3260 }
3261
3262 static void __exit nf_tables_module_exit(void)
3263 {
3264         unregister_pernet_subsys(&nf_tables_net_ops);
3265         nfnetlink_subsys_unregister(&nf_tables_subsys);
3266         nf_tables_core_module_exit();
3267         kfree(info);
3268 }
3269
3270 module_init(nf_tables_module_init);
3271 module_exit(nf_tables_module_exit);
3272
3273 MODULE_LICENSE("GPL");
3274 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>");
3275 MODULE_ALIAS_NFNL_SUBSYS(NFNL_SUBSYS_NFTABLES);