net/netfilter/nft_meta.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2008-2009 Patrick McHardy <kaber@trash.net>
   4  * Copyright (c) 2014 Intel Corporation
   5  * Author: Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
   6  *
   7  * Development of this code funded by Astaro AG (http://www.astaro.com/)
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/netlink.h>
  12 #include <linux/netfilter.h>
  13 #include <linux/netfilter/nf_tables.h>
  14 #include <linux/in.h>
  15 #include <linux/ip.h>
  16 #include <linux/ipv6.h>
  17 #include <linux/smp.h>
  18 #include <linux/static_key.h>
  19 #include <net/dst.h>
  20 #include <net/sock.h>
  21 #include <net/tcp_states.h> /* for TCP_TIME_WAIT */
  22 #include <net/netfilter/nf_tables.h>
  23 #include <net/netfilter/nf_tables_core.h>
  24 #include <net/netfilter/nft_meta.h>
  25 #include <net/netfilter/nf_tables_offload.h>
  26
  27 #include <uapi/linux/netfilter_bridge.h> /* NF_BR_PRE_ROUTING */
  28
  29 #define NFT_META_SECS_PER_MINUTE        60
  30 #define NFT_META_SECS_PER_HOUR          3600
  31 #define NFT_META_SECS_PER_DAY           86400
  32 #define NFT_META_DAYS_PER_WEEK          7
  33
  34 static DEFINE_PER_CPU(struct rnd_state, nft_prandom_state);
  35
  36 static u8 nft_meta_weekday(void)
  37 {
  38         time64_t secs = ktime_get_real_seconds();
  39         unsigned int dse;
  40         u8 wday;
  41
  42         secs -= NFT_META_SECS_PER_MINUTE * sys_tz.tz_minuteswest;
  43         dse = div_u64(secs, NFT_META_SECS_PER_DAY);
  44         wday = (4 + dse) % NFT_META_DAYS_PER_WEEK;
  45
  46         return wday;
  47 }
  48
  49 static u32 nft_meta_hour(time64_t secs)
  50 {
  51         struct tm tm;
  52
  53         time64_to_tm(secs, 0, &tm);
  54
  55         return tm.tm_hour * NFT_META_SECS_PER_HOUR
  56                 + tm.tm_min * NFT_META_SECS_PER_MINUTE
  57                 + tm.tm_sec;
  58 }
  59
  60 static noinline_for_stack void
  61 nft_meta_get_eval_time(enum nft_meta_keys key,
  62                        u32 *dest)
  63 {
  64         switch (key) {
  65         case NFT_META_TIME_NS:
  66                 nft_reg_store64(dest, ktime_get_real_ns());
  67                 break;
  68         case NFT_META_TIME_DAY:
  69                 nft_reg_store8(dest, nft_meta_weekday());
  70                 break;
  71         case NFT_META_TIME_HOUR:
  72                 *dest = nft_meta_hour(ktime_get_real_seconds());
  73                 break;
  74         default:
  75                 break;
  76         }
  77 }
  78
  79 void nft_meta_get_eval(const struct nft_expr *expr,
  80                        struct nft_regs *regs,
  81                        const struct nft_pktinfo *pkt)
  82 {
  83         const struct nft_meta *priv = nft_expr_priv(expr);
  84         const struct sk_buff *skb = pkt->skb;
  85         const struct net_device *in = nft_in(pkt), *out = nft_out(pkt);
  86         struct sock *sk;
  87         u32 *dest = &regs->data[priv->dreg];
  88
  89         switch (priv->key) {
  90         case NFT_META_LEN:
  91                 *dest = skb->len;
  92                 break;
  93         case NFT_META_PROTOCOL:
  94                 nft_reg_store16(dest, (__force u16)skb->protocol);
  95                 break;
  96         case NFT_META_NFPROTO:
  97                 nft_reg_store8(dest, nft_pf(pkt));
  98                 break;
  99         case NFT_META_L4PROTO:
 100                 if (!pkt->tprot_set)
 101                         goto err;
 102                 nft_reg_store8(dest, pkt->tprot);
 103                 break;
 104         case NFT_META_PRIORITY:
 105                 *dest = skb->priority;
 106                 break;
 107         case NFT_META_MARK:
 108                 *dest = skb->mark;
 109                 break;
 110         case NFT_META_IIF:
 111                 *dest = in ? in->ifindex : 0;
 112                 break;
 113         case NFT_META_OIF:
 114                 *dest = out ? out->ifindex : 0;
 115                 break;
 116         case NFT_META_IIFNAME:
 117                 strncpy((char *)dest, in ? in->name : "", IFNAMSIZ);
 118                 break;
 119         case NFT_META_OIFNAME:
 120                 strncpy((char *)dest, out ? out->name : "", IFNAMSIZ);
 121                 break;
 122         case NFT_META_IIFTYPE:
 123                 if (in == NULL)
 124                         goto err;
 125                 nft_reg_store16(dest, in->type);
 126                 break;
 127         case NFT_META_OIFTYPE:
 128                 if (out == NULL)
 129                         goto err;
 130                 nft_reg_store16(dest, out->type);
 131                 break;
 132         case NFT_META_SKUID:
 133                 sk = skb_to_full_sk(skb);
 134                 if (!sk || !sk_fullsock(sk) ||
 135                     !net_eq(nft_net(pkt), sock_net(sk)))
 136                         goto err;
 137
 138                 read_lock_bh(&sk->sk_callback_lock);
 139                 if (sk->sk_socket == NULL ||
 140                     sk->sk_socket->file == NULL) {
 141                         read_unlock_bh(&sk->sk_callback_lock);
 142                         goto err;
 143                 }
 144
 145                 *dest = from_kuid_munged(&init_user_ns,
 146                                 sk->sk_socket->file->f_cred->fsuid);
 147                 read_unlock_bh(&sk->sk_callback_lock);
 148                 break;
 149         case NFT_META_SKGID:
 150                 sk = skb_to_full_sk(skb);
 151                 if (!sk || !sk_fullsock(sk) ||
 152                     !net_eq(nft_net(pkt), sock_net(sk)))
 153                         goto err;
 154
 155                 read_lock_bh(&sk->sk_callback_lock);
 156                 if (sk->sk_socket == NULL ||
 157                     sk->sk_socket->file == NULL) {
 158                         read_unlock_bh(&sk->sk_callback_lock);
 159                         goto err;
 160                 }
 161                 *dest = from_kgid_munged(&init_user_ns,
 162                                  sk->sk_socket->file->f_cred->fsgid);
 163                 read_unlock_bh(&sk->sk_callback_lock);
 164                 break;
 165 #ifdef CONFIG_IP_ROUTE_CLASSID
 166         case NFT_META_RTCLASSID: {
 167                 const struct dst_entry *dst = skb_dst(skb);
 168
 169                 if (dst == NULL)
 170                         goto err;
 171                 *dest = dst->tclassid;
 172                 break;
 173         }
 174 #endif
 175 #ifdef CONFIG_NETWORK_SECMARK
 176         case NFT_META_SECMARK:
 177                 *dest = skb->secmark;
 178                 break;
 179 #endif
 180         case NFT_META_PKTTYPE:
 181                 if (skb->pkt_type != PACKET_LOOPBACK) {
 182                         nft_reg_store8(dest, skb->pkt_type);
 183                         break;
 184                 }
 185
 186                 switch (nft_pf(pkt)) {
 187                 case NFPROTO_IPV4:
 188                         if (ipv4_is_multicast(ip_hdr(skb)->daddr))
 189                                 nft_reg_store8(dest, PACKET_MULTICAST);
 190                         else
 191                                 nft_reg_store8(dest, PACKET_BROADCAST);
 192                         break;
 193                 case NFPROTO_IPV6:
 194                         nft_reg_store8(dest, PACKET_MULTICAST);
 195                         break;
 196                 case NFPROTO_NETDEV:
 197                         switch (skb->protocol) {
 198                         case htons(ETH_P_IP): {
 199                                 int noff = skb_network_offset(skb);
 200                                 struct iphdr *iph, _iph;
 201
 202                                 iph = skb_header_pointer(skb, noff,
 203                                                          sizeof(_iph), &_iph);
 204                                 if (!iph)
 205                                         goto err;
 206
 207                                 if (ipv4_is_multicast(iph->daddr))
 208                                         nft_reg_store8(dest, PACKET_MULTICAST);
 209                                 else
 210                                         nft_reg_store8(dest, PACKET_BROADCAST);
 211
 212                                 break;
 213                         }
 214                         case htons(ETH_P_IPV6):
 215                                 nft_reg_store8(dest, PACKET_MULTICAST);
 216                                 break;
 217                         default:
 218                                 WARN_ON_ONCE(1);
 219                                 goto err;
 220                         }
 221                         break;
 222                 default:
 223                         WARN_ON_ONCE(1);
 224                         goto err;
 225                 }
 226                 break;
 227         case NFT_META_CPU:
 228                 *dest = raw_smp_processor_id();
 229                 break;
 230         case NFT_META_IIFGROUP:
 231                 if (in == NULL)
 232                         goto err;
 233                 *dest = in->group;
 234                 break;
 235         case NFT_META_OIFGROUP:
 236                 if (out == NULL)
 237                         goto err;
 238                 *dest = out->group;
 239                 break;
 240 #ifdef CONFIG_CGROUP_NET_CLASSID
 241         case NFT_META_CGROUP:
 242                 sk = skb_to_full_sk(skb);
 243                 if (!sk || !sk_fullsock(sk) ||
 244                     !net_eq(nft_net(pkt), sock_net(sk)))
 245                         goto err;
 246                 *dest = sock_cgroup_classid(&sk->sk_cgrp_data);
 247                 break;
 248 #endif
 249         case NFT_META_PRANDOM: {
 250                 struct rnd_state *state = this_cpu_ptr(&nft_prandom_state);
 251                 *dest = prandom_u32_state(state);
 252                 break;
 253         }
 254 #ifdef CONFIG_XFRM
 255         case NFT_META_SECPATH:
 256                 nft_reg_store8(dest, secpath_exists(skb));
 257                 break;
 258 #endif
 259         case NFT_META_IIFKIND:
 260                 if (in == NULL || in->rtnl_link_ops == NULL)
 261                         goto err;
 262                 strncpy((char *)dest, in->rtnl_link_ops->kind, IFNAMSIZ);
 263                 break;
 264         case NFT_META_OIFKIND:
 265                 if (out == NULL || out->rtnl_link_ops == NULL)
 266                         goto err;
 267                 strncpy((char *)dest, out->rtnl_link_ops->kind, IFNAMSIZ);
 268                 break;
 269         case NFT_META_TIME_NS:
 270         case NFT_META_TIME_DAY:
 271         case NFT_META_TIME_HOUR:
 272                 nft_meta_get_eval_time(priv->key, dest);
 273                 break;
 274         default:
 275                 WARN_ON(1);
 276                 goto err;
 277         }
 278         return;
 279
 280 err:
 281         regs->verdict.code = NFT_BREAK;
 282 }
 283 EXPORT_SYMBOL_GPL(nft_meta_get_eval);
 284
 285 void nft_meta_set_eval(const struct nft_expr *expr,
 286                        struct nft_regs *regs,
 287                        const struct nft_pktinfo *pkt)
 288 {
 289         const struct nft_meta *meta = nft_expr_priv(expr);
 290         struct sk_buff *skb = pkt->skb;
 291         u32 *sreg = &regs->data[meta->sreg];
 292         u32 value = *sreg;
 293         u8 value8;
 294
 295         switch (meta->key) {
 296         case NFT_META_MARK:
 297                 skb->mark = value;
 298                 break;
 299         case NFT_META_PRIORITY:
 300                 skb->priority = value;
 301                 break;
 302         case NFT_META_PKTTYPE:
 303                 value8 = nft_reg_load8(sreg);
 304
 305                 if (skb->pkt_type != value8 &&
 306                     skb_pkt_type_ok(value8) &&
 307                     skb_pkt_type_ok(skb->pkt_type))
 308                         skb->pkt_type = value8;
 309                 break;
 310         case NFT_META_NFTRACE:
 311                 value8 = nft_reg_load8(sreg);
 312
 313                 skb->nf_trace = !!value8;
 314                 break;
 315 #ifdef CONFIG_NETWORK_SECMARK
 316         case NFT_META_SECMARK:
 317                 skb->secmark = value;
 318                 break;
 319 #endif
 320         default:
 321                 WARN_ON(1);
 322         }
 323 }
 324 EXPORT_SYMBOL_GPL(nft_meta_set_eval);
 325
 326 const struct nla_policy nft_meta_policy[NFTA_META_MAX + 1] = {
 327         [NFTA_META_DREG]        = { .type = NLA_U32 },
 328         [NFTA_META_KEY]         = { .type = NLA_U32 },
 329         [NFTA_META_SREG]        = { .type = NLA_U32 },
 330 };
 331 EXPORT_SYMBOL_GPL(nft_meta_policy);
 332
 333 int nft_meta_get_init(const struct nft_ctx *ctx,
 334                       const struct nft_expr *expr,
 335                       const struct nlattr * const tb[])
 336 {
 337         struct nft_meta *priv = nft_expr_priv(expr);
 338         unsigned int len;
 339
 340         priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
 341         switch (priv->key) {
 342         case NFT_META_PROTOCOL:
 343         case NFT_META_IIFTYPE:
 344         case NFT_META_OIFTYPE:
 345                 len = sizeof(u16);
 346                 break;
 347         case NFT_META_NFPROTO:
 348         case NFT_META_L4PROTO:
 349         case NFT_META_LEN:
 350         case NFT_META_PRIORITY:
 351         case NFT_META_MARK:
 352         case NFT_META_IIF:
 353         case NFT_META_OIF:
 354         case NFT_META_SKUID:
 355         case NFT_META_SKGID:
 356 #ifdef CONFIG_IP_ROUTE_CLASSID
 357         case NFT_META_RTCLASSID:
 358 #endif
 359 #ifdef CONFIG_NETWORK_SECMARK
 360         case NFT_META_SECMARK:
 361 #endif
 362         case NFT_META_PKTTYPE:
 363         case NFT_META_CPU:
 364         case NFT_META_IIFGROUP:
 365         case NFT_META_OIFGROUP:
 366 #ifdef CONFIG_CGROUP_NET_CLASSID
 367         case NFT_META_CGROUP:
 368 #endif
 369                 len = sizeof(u32);
 370                 break;
 371         case NFT_META_IIFNAME:
 372         case NFT_META_OIFNAME:
 373         case NFT_META_IIFKIND:
 374         case NFT_META_OIFKIND:
 375                 len = IFNAMSIZ;
 376                 break;
 377         case NFT_META_PRANDOM:
 378                 prandom_init_once(&nft_prandom_state);
 379                 len = sizeof(u32);
 380                 break;
 381 #ifdef CONFIG_XFRM
 382         case NFT_META_SECPATH:
 383                 len = sizeof(u8);
 384                 break;
 385 #endif
 386         case NFT_META_TIME_NS:
 387                 len = sizeof(u64);
 388                 break;
 389         case NFT_META_TIME_DAY:
 390                 len = sizeof(u8);
 391                 break;
 392         case NFT_META_TIME_HOUR:
 393                 len = sizeof(u32);
 394                 break;
 395         default:
 396                 return -EOPNOTSUPP;
 397         }
 398
 399         priv->dreg = nft_parse_register(tb[NFTA_META_DREG]);
 400         return nft_validate_register_store(ctx, priv->dreg, NULL,
 401                                            NFT_DATA_VALUE, len);
 402 }
 403 EXPORT_SYMBOL_GPL(nft_meta_get_init);
 404
 405 static int nft_meta_get_validate(const struct nft_ctx *ctx,
 406                                  const struct nft_expr *expr,
 407                                  const struct nft_data **data)
 408 {
 409 #ifdef CONFIG_XFRM
 410         const struct nft_meta *priv = nft_expr_priv(expr);
 411         unsigned int hooks;
 412
 413         if (priv->key != NFT_META_SECPATH)
 414                 return 0;
 415
 416         switch (ctx->family) {
 417         case NFPROTO_NETDEV:
 418                 hooks = 1 << NF_NETDEV_INGRESS;
 419                 break;
 420         case NFPROTO_IPV4:
 421         case NFPROTO_IPV6:
 422         case NFPROTO_INET:
 423                 hooks = (1 << NF_INET_PRE_ROUTING) |
 424                         (1 << NF_INET_LOCAL_IN) |
 425                         (1 << NF_INET_FORWARD);
 426                 break;
 427         default:
 428                 return -EOPNOTSUPP;
 429         }
 430
 431         return nft_chain_validate_hooks(ctx->chain, hooks);
 432 #else
 433         return 0;
 434 #endif
 435 }
 436
 437 int nft_meta_set_validate(const struct nft_ctx *ctx,
 438                           const struct nft_expr *expr,
 439                           const struct nft_data **data)
 440 {
 441         struct nft_meta *priv = nft_expr_priv(expr);
 442         unsigned int hooks;
 443
 444         if (priv->key != NFT_META_PKTTYPE)
 445                 return 0;
 446
 447         switch (ctx->family) {
 448         case NFPROTO_BRIDGE:
 449                 hooks = 1 << NF_BR_PRE_ROUTING;
 450                 break;
 451         case NFPROTO_NETDEV:
 452                 hooks = 1 << NF_NETDEV_INGRESS;
 453                 break;
 454         case NFPROTO_IPV4:
 455         case NFPROTO_IPV6:
 456         case NFPROTO_INET:
 457                 hooks = 1 << NF_INET_PRE_ROUTING;
 458                 break;
 459         default:
 460                 return -EOPNOTSUPP;
 461         }
 462
 463         return nft_chain_validate_hooks(ctx->chain, hooks);
 464 }
 465 EXPORT_SYMBOL_GPL(nft_meta_set_validate);
 466
 467 int nft_meta_set_init(const struct nft_ctx *ctx,
 468                       const struct nft_expr *expr,
 469                       const struct nlattr * const tb[])
 470 {
 471         struct nft_meta *priv = nft_expr_priv(expr);
 472         unsigned int len;
 473         int err;
 474
 475         priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
 476         switch (priv->key) {
 477         case NFT_META_MARK:
 478         case NFT_META_PRIORITY:
 479 #ifdef CONFIG_NETWORK_SECMARK
 480         case NFT_META_SECMARK:
 481 #endif
 482                 len = sizeof(u32);
 483                 break;
 484         case NFT_META_NFTRACE:
 485                 len = sizeof(u8);
 486                 break;
 487         case NFT_META_PKTTYPE:
 488                 len = sizeof(u8);
 489                 break;
 490         default:
 491                 return -EOPNOTSUPP;
 492         }
 493
 494         priv->sreg = nft_parse_register(tb[NFTA_META_SREG]);
 495         err = nft_validate_register_load(priv->sreg, len);
 496         if (err < 0)
 497                 return err;
 498
 499         if (priv->key == NFT_META_NFTRACE)
 500                 static_branch_inc(&nft_trace_enabled);
 501
 502         return 0;
 503 }
 504 EXPORT_SYMBOL_GPL(nft_meta_set_init);
 505
 506 int nft_meta_get_dump(struct sk_buff *skb,
 507                       const struct nft_expr *expr)
 508 {
 509         const struct nft_meta *priv = nft_expr_priv(expr);
 510
 511         if (nla_put_be32(skb, NFTA_META_KEY, htonl(priv->key)))
 512                 goto nla_put_failure;
 513         if (nft_dump_register(skb, NFTA_META_DREG, priv->dreg))
 514                 goto nla_put_failure;
 515         return 0;
 516
 517 nla_put_failure:
 518         return -1;
 519 }
 520 EXPORT_SYMBOL_GPL(nft_meta_get_dump);
 521
 522 int nft_meta_set_dump(struct sk_buff *skb, const struct nft_expr *expr)
 523 {
 524         const struct nft_meta *priv = nft_expr_priv(expr);
 525
 526         if (nla_put_be32(skb, NFTA_META_KEY, htonl(priv->key)))
 527                 goto nla_put_failure;
 528         if (nft_dump_register(skb, NFTA_META_SREG, priv->sreg))
 529                 goto nla_put_failure;
 530
 531         return 0;
 532
 533 nla_put_failure:
 534         return -1;
 535 }
 536 EXPORT_SYMBOL_GPL(nft_meta_set_dump);
 537
 538 void nft_meta_set_destroy(const struct nft_ctx *ctx,
 539                           const struct nft_expr *expr)
 540 {
 541         const struct nft_meta *priv = nft_expr_priv(expr);
 542
 543         if (priv->key == NFT_META_NFTRACE)
 544                 static_branch_dec(&nft_trace_enabled);
 545 }
 546 EXPORT_SYMBOL_GPL(nft_meta_set_destroy);
 547
 548 static int nft_meta_get_offload(struct nft_offload_ctx *ctx,
 549                                 struct nft_flow_rule *flow,
 550                                 const struct nft_expr *expr)
 551 {
 552         const struct nft_meta *priv = nft_expr_priv(expr);
 553         struct nft_offload_reg *reg = &ctx->regs[priv->dreg];
 554
 555         switch (priv->key) {
 556         case NFT_META_PROTOCOL:
 557                 NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_BASIC, basic, n_proto,
 558                                   sizeof(__u16), reg);
 559                 nft_offload_set_dependency(ctx, NFT_OFFLOAD_DEP_NETWORK);
 560                 break;
 561         case NFT_META_L4PROTO:
 562                 NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_BASIC, basic, ip_proto,
 563                                   sizeof(__u8), reg);
 564                 nft_offload_set_dependency(ctx, NFT_OFFLOAD_DEP_TRANSPORT);
 565                 break;
 566         case NFT_META_IIF:
 567                 NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_META, meta,
 568                                   ingress_ifindex, sizeof(__u32), reg);
 569                 break;
 570         case NFT_META_IIFTYPE:
 571                 NFT_OFFLOAD_MATCH(FLOW_DISSECTOR_KEY_META, meta,
 572                                   ingress_iftype, sizeof(__u16), reg);
 573                 break;
 574         default:
 575                 return -EOPNOTSUPP;
 576         }
 577
 578         return 0;
 579 }
 580
 581 static const struct nft_expr_ops nft_meta_get_ops = {
 582         .type           = &nft_meta_type,
 583         .size           = NFT_EXPR_SIZE(sizeof(struct nft_meta)),
 584         .eval           = nft_meta_get_eval,
 585         .init           = nft_meta_get_init,
 586         .dump           = nft_meta_get_dump,
 587         .validate       = nft_meta_get_validate,
 588         .offload        = nft_meta_get_offload,
 589 };
 590
 591 static const struct nft_expr_ops nft_meta_set_ops = {
 592         .type           = &nft_meta_type,
 593         .size           = NFT_EXPR_SIZE(sizeof(struct nft_meta)),
 594         .eval           = nft_meta_set_eval,
 595         .init           = nft_meta_set_init,
 596         .destroy        = nft_meta_set_destroy,
 597         .dump           = nft_meta_set_dump,
 598         .validate       = nft_meta_set_validate,
 599 };
 600
 601 static const struct nft_expr_ops *
 602 nft_meta_select_ops(const struct nft_ctx *ctx,
 603                     const struct nlattr * const tb[])
 604 {
 605         if (tb[NFTA_META_KEY] == NULL)
 606                 return ERR_PTR(-EINVAL);
 607
 608         if (tb[NFTA_META_DREG] && tb[NFTA_META_SREG])
 609                 return ERR_PTR(-EINVAL);
 610
 611 #if IS_ENABLED(CONFIG_NF_TABLES_BRIDGE) && IS_MODULE(CONFIG_NFT_BRIDGE_META)
 612         if (ctx->family == NFPROTO_BRIDGE)
 613                 return ERR_PTR(-EAGAIN);
 614 #endif
 615         if (tb[NFTA_META_DREG])
 616                 return &nft_meta_get_ops;
 617
 618         if (tb[NFTA_META_SREG])
 619                 return &nft_meta_set_ops;
 620
 621         return ERR_PTR(-EINVAL);
 622 }
 623
 624 struct nft_expr_type nft_meta_type __read_mostly = {
 625         .name           = "meta",
 626         .select_ops     = nft_meta_select_ops,
 627         .policy         = nft_meta_policy,
 628         .maxattr        = NFTA_META_MAX,
 629         .owner          = THIS_MODULE,
 630 };
 631
 632 #ifdef CONFIG_NETWORK_SECMARK
 633 struct nft_secmark {
 634         u32 secid;
 635         char *ctx;
 636 };
 637
 638 static const struct nla_policy nft_secmark_policy[NFTA_SECMARK_MAX + 1] = {
 639         [NFTA_SECMARK_CTX]     = { .type = NLA_STRING, .len = NFT_SECMARK_CTX_MAXLEN },
 640 };
 641
 642 static int nft_secmark_compute_secid(struct nft_secmark *priv)
 643 {
 644         u32 tmp_secid = 0;
 645         int err;
 646
 647         err = security_secctx_to_secid(priv->ctx, strlen(priv->ctx), &tmp_secid);
 648         if (err)
 649                 return err;
 650
 651         if (!tmp_secid)
 652                 return -ENOENT;
 653
 654         err = security_secmark_relabel_packet(tmp_secid);
 655         if (err)
 656                 return err;
 657
 658         priv->secid = tmp_secid;
 659         return 0;
 660 }
 661
 662 static void nft_secmark_obj_eval(struct nft_object *obj, struct nft_regs *regs,
 663                                  const struct nft_pktinfo *pkt)
 664 {
 665         const struct nft_secmark *priv = nft_obj_data(obj);
 666         struct sk_buff *skb = pkt->skb;
 667
 668         skb->secmark = priv->secid;
 669 }
 670
 671 static int nft_secmark_obj_init(const struct nft_ctx *ctx,
 672                                 const struct nlattr * const tb[],
 673                                 struct nft_object *obj)
 674 {
 675         struct nft_secmark *priv = nft_obj_data(obj);
 676         int err;
 677
 678         if (tb[NFTA_SECMARK_CTX] == NULL)
 679                 return -EINVAL;
 680
 681         priv->ctx = nla_strdup(tb[NFTA_SECMARK_CTX], GFP_KERNEL);
 682         if (!priv->ctx)
 683                 return -ENOMEM;
 684
 685         err = nft_secmark_compute_secid(priv);
 686         if (err) {
 687                 kfree(priv->ctx);
 688                 return err;
 689         }
 690
 691         security_secmark_refcount_inc();
 692
 693         return 0;
 694 }
 695
 696 static int nft_secmark_obj_dump(struct sk_buff *skb, struct nft_object *obj,
 697                                 bool reset)
 698 {
 699         struct nft_secmark *priv = nft_obj_data(obj);
 700         int err;
 701
 702         if (nla_put_string(skb, NFTA_SECMARK_CTX, priv->ctx))
 703                 return -1;
 704
 705         if (reset) {
 706                 err = nft_secmark_compute_secid(priv);
 707                 if (err)
 708                         return err;
 709         }
 710
 711         return 0;
 712 }
 713
 714 static void nft_secmark_obj_destroy(const struct nft_ctx *ctx, struct nft_object *obj)
 715 {
 716         struct nft_secmark *priv = nft_obj_data(obj);
 717
 718         security_secmark_refcount_dec();
 719
 720         kfree(priv->ctx);
 721 }
 722
 723 static const struct nft_object_ops nft_secmark_obj_ops = {
 724         .type           = &nft_secmark_obj_type,
 725         .size           = sizeof(struct nft_secmark),
 726         .init           = nft_secmark_obj_init,
 727         .eval           = nft_secmark_obj_eval,
 728         .dump           = nft_secmark_obj_dump,
 729         .destroy        = nft_secmark_obj_destroy,
 730 };
 731 struct nft_object_type nft_secmark_obj_type __read_mostly = {
 732         .type           = NFT_OBJECT_SECMARK,
 733         .ops            = &nft_secmark_obj_ops,
 734         .maxattr        = NFTA_SECMARK_MAX,
 735         .policy         = nft_secmark_policy,
 736         .owner          = THIS_MODULE,
 737 };
 738 #endif /* CONFIG_NETWORK_SECMARK */