net/netfilter/nft_dynset.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2015 Patrick McHardy <kaber@trash.net>
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/module.h>
   8 #include <linux/init.h>
   9 #include <linux/netlink.h>
  10 #include <linux/netfilter.h>
  11 #include <linux/netfilter/nf_tables.h>
  12 #include <net/netfilter/nf_tables.h>
  13 #include <net/netfilter/nf_tables_core.h>
  14
  15 struct nft_dynset {
  16         struct nft_set                  *set;
  17         struct nft_set_ext_tmpl         tmpl;
  18         enum nft_dynset_ops             op:8;
  19         enum nft_registers              sreg_key:8;
  20         enum nft_registers              sreg_data:8;
  21         bool                            invert;
  22         u8                              num_exprs;
  23         u64                             timeout;
  24         struct nft_expr                 *expr_array[NFT_SET_EXPR_MAX];
  25         struct nft_set_binding          binding;
  26 };
  27
  28 static int nft_dynset_expr_setup(const struct nft_dynset *priv,
  29                                  const struct nft_set_ext *ext)
  30 {
  31         struct nft_set_elem_expr *elem_expr = nft_set_ext_expr(ext);
  32         struct nft_expr *expr;
  33         int i;
  34
  35         for (i = 0; i < priv->num_exprs; i++) {
  36                 expr = nft_setelem_expr_at(elem_expr, elem_expr->size);
  37                 if (nft_expr_clone(expr, priv->expr_array[i]) < 0)
  38                         return -1;
  39
  40                 elem_expr->size += priv->expr_array[i]->ops->size;
  41         }
  42
  43         return 0;
  44 }
  45
  46 static void *nft_dynset_new(struct nft_set *set, const struct nft_expr *expr,
  47                             struct nft_regs *regs)
  48 {
  49         const struct nft_dynset *priv = nft_expr_priv(expr);
  50         struct nft_set_ext *ext;
  51         u64 timeout;
  52         void *elem;
  53
  54         if (!atomic_add_unless(&set->nelems, 1, set->size))
  55                 return NULL;
  56
  57         timeout = priv->timeout ? : set->timeout;
  58         elem = nft_set_elem_init(set, &priv->tmpl,
  59                                  &regs->data[priv->sreg_key], NULL,
  60                                  &regs->data[priv->sreg_data],
  61                                  timeout, 0, GFP_ATOMIC);
  62         if (elem == NULL)
  63                 goto err1;
  64
  65         ext = nft_set_elem_ext(set, elem);
  66         if (priv->num_exprs && nft_dynset_expr_setup(priv, ext) < 0)
  67                 goto err2;
  68
  69         return elem;
  70
  71 err2:
  72         nft_set_elem_destroy(set, elem, false);
  73 err1:
  74         if (set->size)
  75                 atomic_dec(&set->nelems);
  76         return NULL;
  77 }
  78
  79 void nft_dynset_eval(const struct nft_expr *expr,
  80                      struct nft_regs *regs, const struct nft_pktinfo *pkt)
  81 {
  82         const struct nft_dynset *priv = nft_expr_priv(expr);
  83         struct nft_set *set = priv->set;
  84         const struct nft_set_ext *ext;
  85         u64 timeout;
  86
  87         if (priv->op == NFT_DYNSET_OP_DELETE) {
  88                 set->ops->delete(set, &regs->data[priv->sreg_key]);
  89                 return;
  90         }
  91
  92         if (set->ops->update(set, &regs->data[priv->sreg_key], nft_dynset_new,
  93                              expr, regs, &ext)) {
  94                 if (priv->op == NFT_DYNSET_OP_UPDATE &&
  95                     nft_set_ext_exists(ext, NFT_SET_EXT_EXPIRATION)) {
  96                         timeout = priv->timeout ? : set->timeout;
  97                         *nft_set_ext_expiration(ext) = get_jiffies_64() + timeout;
  98                 }
  99
 100                 nft_set_elem_update_expr(ext, regs, pkt);
 101
 102                 if (priv->invert)
 103                         regs->verdict.code = NFT_BREAK;
 104                 return;
 105         }
 106
 107         if (!priv->invert)
 108                 regs->verdict.code = NFT_BREAK;
 109 }
 110
 111 static void nft_dynset_ext_add_expr(struct nft_dynset *priv)
 112 {
 113         u8 size = 0;
 114         int i;
 115
 116         for (i = 0; i < priv->num_exprs; i++)
 117                 size += priv->expr_array[i]->ops->size;
 118
 119         nft_set_ext_add_length(&priv->tmpl, NFT_SET_EXT_EXPRESSIONS,
 120                                sizeof(struct nft_set_elem_expr) + size);
 121 }
 122
 123 static struct nft_expr *
 124 nft_dynset_expr_alloc(const struct nft_ctx *ctx, const struct nft_set *set,
 125                       const struct nlattr *attr, int pos)
 126 {
 127         struct nft_expr *expr;
 128         int err;
 129
 130         expr = nft_set_elem_expr_alloc(ctx, set, attr);
 131         if (IS_ERR(expr))
 132                 return expr;
 133
 134         if (set->exprs[pos] && set->exprs[pos]->ops != expr->ops) {
 135                 err = -EOPNOTSUPP;
 136                 goto err_dynset_expr;
 137         }
 138
 139         return expr;
 140
 141 err_dynset_expr:
 142         nft_expr_destroy(ctx, expr);
 143         return ERR_PTR(err);
 144 }
 145
 146 static const struct nla_policy nft_dynset_policy[NFTA_DYNSET_MAX + 1] = {
 147         [NFTA_DYNSET_SET_NAME]  = { .type = NLA_STRING,
 148                                     .len = NFT_SET_MAXNAMELEN - 1 },
 149         [NFTA_DYNSET_SET_ID]    = { .type = NLA_U32 },
 150         [NFTA_DYNSET_OP]        = { .type = NLA_U32 },
 151         [NFTA_DYNSET_SREG_KEY]  = { .type = NLA_U32 },
 152         [NFTA_DYNSET_SREG_DATA] = { .type = NLA_U32 },
 153         [NFTA_DYNSET_TIMEOUT]   = { .type = NLA_U64 },
 154         [NFTA_DYNSET_EXPR]      = { .type = NLA_NESTED },
 155         [NFTA_DYNSET_FLAGS]     = { .type = NLA_U32 },
 156         [NFTA_DYNSET_EXPRESSIONS] = { .type = NLA_NESTED },
 157 };
 158
 159 static int nft_dynset_init(const struct nft_ctx *ctx,
 160                            const struct nft_expr *expr,
 161                            const struct nlattr * const tb[])
 162 {
 163         struct nft_dynset *priv = nft_expr_priv(expr);
 164         u8 genmask = nft_genmask_next(ctx->net);
 165         struct nft_set *set;
 166         u64 timeout;
 167         int err, i;
 168
 169         lockdep_assert_held(&ctx->net->nft.commit_mutex);
 170
 171         if (tb[NFTA_DYNSET_SET_NAME] == NULL ||
 172             tb[NFTA_DYNSET_OP] == NULL ||
 173             tb[NFTA_DYNSET_SREG_KEY] == NULL)
 174                 return -EINVAL;
 175
 176         if (tb[NFTA_DYNSET_FLAGS]) {
 177                 u32 flags = ntohl(nla_get_be32(tb[NFTA_DYNSET_FLAGS]));
 178
 179                 if (flags & ~NFT_DYNSET_F_INV)
 180                         return -EINVAL;
 181                 if (flags & NFT_DYNSET_F_INV)
 182                         priv->invert = true;
 183         }
 184
 185         set = nft_set_lookup_global(ctx->net, ctx->table,
 186                                     tb[NFTA_DYNSET_SET_NAME],
 187                                     tb[NFTA_DYNSET_SET_ID], genmask);
 188         if (IS_ERR(set))
 189                 return PTR_ERR(set);
 190
 191         if (set->ops->update == NULL)
 192                 return -EOPNOTSUPP;
 193
 194         if (set->flags & NFT_SET_CONSTANT)
 195                 return -EBUSY;
 196
 197         priv->op = ntohl(nla_get_be32(tb[NFTA_DYNSET_OP]));
 198         switch (priv->op) {
 199         case NFT_DYNSET_OP_ADD:
 200         case NFT_DYNSET_OP_DELETE:
 201                 break;
 202         case NFT_DYNSET_OP_UPDATE:
 203                 if (!(set->flags & NFT_SET_TIMEOUT))
 204                         return -EOPNOTSUPP;
 205                 break;
 206         default:
 207                 return -EOPNOTSUPP;
 208         }
 209
 210         timeout = 0;
 211         if (tb[NFTA_DYNSET_TIMEOUT] != NULL) {
 212                 if (!(set->flags & NFT_SET_TIMEOUT))
 213                         return -EINVAL;
 214
 215                 err = nf_msecs_to_jiffies64(tb[NFTA_DYNSET_TIMEOUT], &timeout);
 216                 if (err)
 217                         return err;
 218         }
 219
 220         priv->sreg_key = nft_parse_register(tb[NFTA_DYNSET_SREG_KEY]);
 221         err = nft_validate_register_load(priv->sreg_key, set->klen);
 222         if (err < 0)
 223                 return err;
 224
 225         if (tb[NFTA_DYNSET_SREG_DATA] != NULL) {
 226                 if (!(set->flags & NFT_SET_MAP))
 227                         return -EINVAL;
 228                 if (set->dtype == NFT_DATA_VERDICT)
 229                         return -EOPNOTSUPP;
 230
 231                 priv->sreg_data = nft_parse_register(tb[NFTA_DYNSET_SREG_DATA]);
 232                 err = nft_validate_register_load(priv->sreg_data, set->dlen);
 233                 if (err < 0)
 234                         return err;
 235         } else if (set->flags & NFT_SET_MAP)
 236                 return -EINVAL;
 237
 238         if ((tb[NFTA_DYNSET_EXPR] || tb[NFTA_DYNSET_EXPRESSIONS]) &&
 239             !(set->flags & NFT_SET_EVAL))
 240                 return -EINVAL;
 241
 242         if (tb[NFTA_DYNSET_EXPR]) {
 243                 struct nft_expr *dynset_expr;
 244
 245                 dynset_expr = nft_dynset_expr_alloc(ctx, set,
 246                                                     tb[NFTA_DYNSET_EXPR], 0);
 247                 if (IS_ERR(dynset_expr))
 248                         return PTR_ERR(dynset_expr);
 249
 250                 priv->num_exprs++;
 251                 priv->expr_array[0] = dynset_expr;
 252
 253                 if (set->num_exprs > 1 ||
 254                     (set->num_exprs == 1 &&
 255                      dynset_expr->ops != set->exprs[0]->ops)) {
 256                         err = -EOPNOTSUPP;
 257                         goto err_expr_free;
 258                 }
 259         } else if (tb[NFTA_DYNSET_EXPRESSIONS]) {
 260                 struct nft_expr *dynset_expr;
 261                 struct nlattr *tmp;
 262                 int left;
 263
 264                 i = 0;
 265                 nla_for_each_nested(tmp, tb[NFTA_DYNSET_EXPRESSIONS], left) {
 266                         if (i == NFT_SET_EXPR_MAX) {
 267                                 err = -E2BIG;
 268                                 goto err_expr_free;
 269                         }
 270                         if (nla_type(tmp) != NFTA_LIST_ELEM) {
 271                                 err = -EINVAL;
 272                                 goto err_expr_free;
 273                         }
 274                         dynset_expr = nft_dynset_expr_alloc(ctx, set, tmp, i);
 275                         if (IS_ERR(dynset_expr)) {
 276                                 err = PTR_ERR(dynset_expr);
 277                                 goto err_expr_free;
 278                         }
 279                         priv->expr_array[i] = dynset_expr;
 280                         priv->num_exprs++;
 281
 282                         if (set->num_exprs &&
 283                             dynset_expr->ops != set->exprs[i]->ops) {
 284                                 err = -EOPNOTSUPP;
 285                                 goto err_expr_free;
 286                         }
 287                         i++;
 288                 }
 289                 if (set->num_exprs && set->num_exprs != i) {
 290                         err = -EOPNOTSUPP;
 291                         goto err_expr_free;
 292                 }
 293         }
 294
 295         nft_set_ext_prepare(&priv->tmpl);
 296         nft_set_ext_add_length(&priv->tmpl, NFT_SET_EXT_KEY, set->klen);
 297         if (set->flags & NFT_SET_MAP)
 298                 nft_set_ext_add_length(&priv->tmpl, NFT_SET_EXT_DATA, set->dlen);
 299
 300         if (priv->num_exprs)
 301                 nft_dynset_ext_add_expr(priv);
 302
 303         if (set->flags & NFT_SET_TIMEOUT) {
 304                 if (timeout || set->timeout)
 305                         nft_set_ext_add(&priv->tmpl, NFT_SET_EXT_EXPIRATION);
 306         }
 307
 308         priv->timeout = timeout;
 309
 310         err = nf_tables_bind_set(ctx, set, &priv->binding);
 311         if (err < 0)
 312                 goto err_expr_free;
 313
 314         if (set->size == 0)
 315                 set->size = 0xffff;
 316
 317         priv->set = set;
 318         return 0;
 319
 320 err_expr_free:
 321         for (i = 0; i < priv->num_exprs; i++)
 322                 nft_expr_destroy(ctx, priv->expr_array[i]);
 323         return err;
 324 }
 325
 326 static void nft_dynset_deactivate(const struct nft_ctx *ctx,
 327                                   const struct nft_expr *expr,
 328                                   enum nft_trans_phase phase)
 329 {
 330         struct nft_dynset *priv = nft_expr_priv(expr);
 331
 332         nf_tables_deactivate_set(ctx, priv->set, &priv->binding, phase);
 333 }
 334
 335 static void nft_dynset_activate(const struct nft_ctx *ctx,
 336                                 const struct nft_expr *expr)
 337 {
 338         struct nft_dynset *priv = nft_expr_priv(expr);
 339
 340         priv->set->use++;
 341 }
 342
 343 static void nft_dynset_destroy(const struct nft_ctx *ctx,
 344                                const struct nft_expr *expr)
 345 {
 346         struct nft_dynset *priv = nft_expr_priv(expr);
 347         int i;
 348
 349         for (i = 0; i < priv->num_exprs; i++)
 350                 nft_expr_destroy(ctx, priv->expr_array[i]);
 351
 352         nf_tables_destroy_set(ctx, priv->set);
 353 }
 354
 355 static int nft_dynset_dump(struct sk_buff *skb, const struct nft_expr *expr)
 356 {
 357         const struct nft_dynset *priv = nft_expr_priv(expr);
 358         u32 flags = priv->invert ? NFT_DYNSET_F_INV : 0;
 359         int i;
 360
 361         if (nft_dump_register(skb, NFTA_DYNSET_SREG_KEY, priv->sreg_key))
 362                 goto nla_put_failure;
 363         if (priv->set->flags & NFT_SET_MAP &&
 364             nft_dump_register(skb, NFTA_DYNSET_SREG_DATA, priv->sreg_data))
 365                 goto nla_put_failure;
 366         if (nla_put_be32(skb, NFTA_DYNSET_OP, htonl(priv->op)))
 367                 goto nla_put_failure;
 368         if (nla_put_string(skb, NFTA_DYNSET_SET_NAME, priv->set->name))
 369                 goto nla_put_failure;
 370         if (nla_put_be64(skb, NFTA_DYNSET_TIMEOUT,
 371                          nf_jiffies64_to_msecs(priv->timeout),
 372                          NFTA_DYNSET_PAD))
 373                 goto nla_put_failure;
 374         if (priv->num_exprs == 1) {
 375                 if (nft_expr_dump(skb, NFTA_DYNSET_EXPR, priv->expr_array[0]))
 376                         goto nla_put_failure;
 377         } else if (priv->num_exprs > 1) {
 378                 struct nlattr *nest;
 379
 380                 nest = nla_nest_start_noflag(skb, NFTA_DYNSET_EXPRESSIONS);
 381                 if (!nest)
 382                         goto nla_put_failure;
 383
 384                 for (i = 0; i < priv->num_exprs; i++) {
 385                         if (nft_expr_dump(skb, NFTA_LIST_ELEM,
 386                                           priv->expr_array[i]))
 387                                 goto nla_put_failure;
 388                 }
 389                 nla_nest_end(skb, nest);
 390         }
 391         if (nla_put_be32(skb, NFTA_DYNSET_FLAGS, htonl(flags)))
 392                 goto nla_put_failure;
 393         return 0;
 394
 395 nla_put_failure:
 396         return -1;
 397 }
 398
 399 static const struct nft_expr_ops nft_dynset_ops = {
 400         .type           = &nft_dynset_type,
 401         .size           = NFT_EXPR_SIZE(sizeof(struct nft_dynset)),
 402         .eval           = nft_dynset_eval,
 403         .init           = nft_dynset_init,
 404         .destroy        = nft_dynset_destroy,
 405         .activate       = nft_dynset_activate,
 406         .deactivate     = nft_dynset_deactivate,
 407         .dump           = nft_dynset_dump,
 408 };
 409
 410 struct nft_expr_type nft_dynset_type __read_mostly = {
 411         .name           = "dynset",
 412         .ops            = &nft_dynset_ops,
 413         .policy         = nft_dynset_policy,
 414         .maxattr        = NFTA_DYNSET_MAX,
 415         .owner          = THIS_MODULE,
 416 };