net/bridge/netfilter/nft_meta_bridge.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/kernel.h>
   3 #include <linux/init.h>
   4 #include <linux/module.h>
   5 #include <linux/netlink.h>
   6 #include <linux/netfilter.h>
   7 #include <linux/netfilter/nf_tables.h>
   8 #include <net/netfilter/nf_tables.h>
   9 #include <net/netfilter/nft_meta.h>
  10 #include <linux/if_bridge.h>
  11
  12 static const struct net_device *
  13 nft_meta_get_bridge(const struct net_device *dev)
  14 {
  15         if (dev && netif_is_bridge_port(dev))
  16                 return netdev_master_upper_dev_get_rcu((struct net_device *)dev);
  17
  18         return NULL;
  19 }
  20
  21 static void nft_meta_bridge_get_eval(const struct nft_expr *expr,
  22                                      struct nft_regs *regs,
  23                                      const struct nft_pktinfo *pkt)
  24 {
  25         const struct nft_meta *priv = nft_expr_priv(expr);
  26         const struct net_device *in = nft_in(pkt), *out = nft_out(pkt);
  27         u32 *dest = &regs->data[priv->dreg];
  28         const struct net_device *br_dev;
  29
  30         switch (priv->key) {
  31         case NFT_META_BRI_IIFNAME:
  32                 br_dev = nft_meta_get_bridge(in);
  33                 if (!br_dev)
  34                         goto err;
  35                 break;
  36         case NFT_META_BRI_OIFNAME:
  37                 br_dev = nft_meta_get_bridge(out);
  38                 if (!br_dev)
  39                         goto err;
  40                 break;
  41         case NFT_META_BRI_IIFPVID: {
  42                 u16 p_pvid;
  43
  44                 br_dev = nft_meta_get_bridge(in);
  45                 if (!br_dev || !br_vlan_enabled(br_dev))
  46                         goto err;
  47
  48                 br_vlan_get_pvid_rcu(in, &p_pvid);
  49                 nft_reg_store16(dest, p_pvid);
  50                 return;
  51         }
  52         case NFT_META_BRI_IIFVPROTO: {
  53                 u16 p_proto;
  54
  55                 br_dev = nft_meta_get_bridge(in);
  56                 if (!br_dev || !br_vlan_enabled(br_dev))
  57                         goto err;
  58
  59                 br_vlan_get_proto(br_dev, &p_proto);
  60                 nft_reg_store16(dest, p_proto);
  61                 return;
  62         }
  63         default:
  64                 goto out;
  65         }
  66
  67         strncpy((char *)dest, br_dev->name, IFNAMSIZ);
  68         return;
  69 out:
  70         return nft_meta_get_eval(expr, regs, pkt);
  71 err:
  72         regs->verdict.code = NFT_BREAK;
  73 }
  74
  75 static int nft_meta_bridge_get_init(const struct nft_ctx *ctx,
  76                                     const struct nft_expr *expr,
  77                                     const struct nlattr * const tb[])
  78 {
  79         struct nft_meta *priv = nft_expr_priv(expr);
  80         unsigned int len;
  81
  82         priv->key = ntohl(nla_get_be32(tb[NFTA_META_KEY]));
  83         switch (priv->key) {
  84         case NFT_META_BRI_IIFNAME:
  85         case NFT_META_BRI_OIFNAME:
  86                 len = IFNAMSIZ;
  87                 break;
  88         case NFT_META_BRI_IIFPVID:
  89         case NFT_META_BRI_IIFVPROTO:
  90                 len = sizeof(u16);
  91                 break;
  92         default:
  93                 return nft_meta_get_init(ctx, expr, tb);
  94         }
  95
  96         priv->dreg = nft_parse_register(tb[NFTA_META_DREG]);
  97         return nft_validate_register_store(ctx, priv->dreg, NULL,
  98                                            NFT_DATA_VALUE, len);
  99 }
 100
 101 static struct nft_expr_type nft_meta_bridge_type;
 102 static const struct nft_expr_ops nft_meta_bridge_get_ops = {
 103         .type           = &nft_meta_bridge_type,
 104         .size           = NFT_EXPR_SIZE(sizeof(struct nft_meta)),
 105         .eval           = nft_meta_bridge_get_eval,
 106         .init           = nft_meta_bridge_get_init,
 107         .dump           = nft_meta_get_dump,
 108 };
 109
 110 static const struct nft_expr_ops nft_meta_bridge_set_ops = {
 111         .type           = &nft_meta_bridge_type,
 112         .size           = NFT_EXPR_SIZE(sizeof(struct nft_meta)),
 113         .eval           = nft_meta_set_eval,
 114         .init           = nft_meta_set_init,
 115         .destroy        = nft_meta_set_destroy,
 116         .dump           = nft_meta_set_dump,
 117         .validate       = nft_meta_set_validate,
 118 };
 119
 120 static const struct nft_expr_ops *
 121 nft_meta_bridge_select_ops(const struct nft_ctx *ctx,
 122                            const struct nlattr * const tb[])
 123 {
 124         if (tb[NFTA_META_KEY] == NULL)
 125                 return ERR_PTR(-EINVAL);
 126
 127         if (tb[NFTA_META_DREG] && tb[NFTA_META_SREG])
 128                 return ERR_PTR(-EINVAL);
 129
 130         if (tb[NFTA_META_DREG])
 131                 return &nft_meta_bridge_get_ops;
 132
 133         if (tb[NFTA_META_SREG])
 134                 return &nft_meta_bridge_set_ops;
 135
 136         return ERR_PTR(-EINVAL);
 137 }
 138
 139 static struct nft_expr_type nft_meta_bridge_type __read_mostly = {
 140         .family         = NFPROTO_BRIDGE,
 141         .name           = "meta",
 142         .select_ops     = nft_meta_bridge_select_ops,
 143         .policy         = nft_meta_policy,
 144         .maxattr        = NFTA_META_MAX,
 145         .owner          = THIS_MODULE,
 146 };
 147
 148 static int __init nft_meta_bridge_module_init(void)
 149 {
 150         return nft_register_expr(&nft_meta_bridge_type);
 151 }
 152
 153 static void __exit nft_meta_bridge_module_exit(void)
 154 {
 155         nft_unregister_expr(&nft_meta_bridge_type);
 156 }
 157
 158 module_init(nft_meta_bridge_module_init);
 159 module_exit(nft_meta_bridge_module_exit);
 160
 161 MODULE_LICENSE("GPL");
 162 MODULE_AUTHOR("wenxu <wenxu@ucloud.cn>");
 163 MODULE_ALIAS_NFT_AF_EXPR(AF_BRIDGE, "meta");