net/netfilter/nf_tables_netdev.c

   1 /*
   2  * Copyright (c) 2015 Pablo Neira Ayuso <pablo@netfilter.org>
   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
   9 #include <linux/init.h>
  10 #include <linux/module.h>
  11 #include <linux/netdevice.h>
  12 #include <net/netfilter/nf_tables.h>
  13 #include <linux/ip.h>
  14 #include <linux/ipv6.h>
  15 #include <net/netfilter/nf_tables_ipv4.h>
  16 #include <net/netfilter/nf_tables_ipv6.h>
  17
  18 static unsigned int
  19 nft_do_chain_netdev(void *priv, struct sk_buff *skb,
  20                     const struct nf_hook_state *state)
  21 {
  22         struct nft_pktinfo pkt;
  23
  24         nft_set_pktinfo(&pkt, skb, state);
  25
  26         switch (skb->protocol) {
  27         case htons(ETH_P_IP):
  28                 nft_set_pktinfo_ipv4_validate(&pkt, skb);
  29                 break;
  30         case htons(ETH_P_IPV6):
  31                 nft_set_pktinfo_ipv6_validate(&pkt, skb);
  32                 break;
  33         default:
  34                 nft_set_pktinfo_unspec(&pkt, skb);
  35                 break;
  36         }
  37
  38         return nft_do_chain(&pkt, priv);
  39 }
  40
  41 static struct nft_af_info nft_af_netdev __read_mostly = {
  42         .family         = NFPROTO_NETDEV,
  43         .owner          = THIS_MODULE,
  44 };
  45
  46 static int nf_tables_netdev_init_net(struct net *net)
  47 {
  48         net->nft.netdev = kmalloc(sizeof(struct nft_af_info), GFP_KERNEL);
  49         if (net->nft.netdev == NULL)
  50                 return -ENOMEM;
  51
  52         memcpy(net->nft.netdev, &nft_af_netdev, sizeof(nft_af_netdev));
  53
  54         if (nft_register_afinfo(net, net->nft.netdev) < 0)
  55                 goto err;
  56
  57         return 0;
  58 err:
  59         kfree(net->nft.netdev);
  60         return -ENOMEM;
  61 }
  62
  63 static void nf_tables_netdev_exit_net(struct net *net)
  64 {
  65         nft_unregister_afinfo(net, net->nft.netdev);
  66         kfree(net->nft.netdev);
  67 }
  68
  69 static struct pernet_operations nf_tables_netdev_net_ops = {
  70         .init   = nf_tables_netdev_init_net,
  71         .exit   = nf_tables_netdev_exit_net,
  72 };
  73
  74 static const struct nf_chain_type nft_filter_chain_netdev = {
  75         .name           = "filter",
  76         .type           = NFT_CHAIN_T_DEFAULT,
  77         .family         = NFPROTO_NETDEV,
  78         .owner          = THIS_MODULE,
  79         .hook_mask      = (1 << NF_NETDEV_INGRESS),
  80         .hooks          = {
  81                 [NF_NETDEV_INGRESS]     = nft_do_chain_netdev,
  82         },
  83 };
  84
  85 static void nft_netdev_event(unsigned long event, struct net_device *dev,
  86                              struct nft_ctx *ctx)
  87 {
  88         struct nft_base_chain *basechain = nft_base_chain(ctx->chain);
  89
  90         switch (event) {
  91         case NETDEV_UNREGISTER:
  92                 if (strcmp(basechain->dev_name, dev->name) != 0)
  93                         return;
  94
  95                 __nft_release_basechain(ctx);
  96                 break;
  97         case NETDEV_CHANGENAME:
  98                 if (dev->ifindex != basechain->ops.dev->ifindex)
  99                         return;
 100
 101                 strncpy(basechain->dev_name, dev->name, IFNAMSIZ);
 102                 break;
 103         }
 104 }
 105
 106 static int nf_tables_netdev_event(struct notifier_block *this,
 107                                   unsigned long event, void *ptr)
 108 {
 109         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 110         struct nft_table *table;
 111         struct nft_chain *chain, *nr;
 112         struct nft_ctx ctx = {
 113                 .net    = dev_net(dev),
 114         };
 115
 116         if (event != NETDEV_UNREGISTER &&
 117             event != NETDEV_CHANGENAME)
 118                 return NOTIFY_DONE;
 119
 120         nfnl_lock(NFNL_SUBSYS_NFTABLES);
 121         list_for_each_entry(table, &ctx.net->nft.tables, list) {
 122                 if (table->afi->family != NFPROTO_NETDEV)
 123                         continue;
 124
 125                 ctx.family = table->afi->family;
 126                 ctx.table = table;
 127                 list_for_each_entry_safe(chain, nr, &table->chains, list) {
 128                         if (!nft_is_base_chain(chain))
 129                                 continue;
 130
 131                         ctx.chain = chain;
 132                         nft_netdev_event(event, dev, &ctx);
 133                 }
 134         }
 135         nfnl_unlock(NFNL_SUBSYS_NFTABLES);
 136
 137         return NOTIFY_DONE;
 138 }
 139
 140 static struct notifier_block nf_tables_netdev_notifier = {
 141         .notifier_call  = nf_tables_netdev_event,
 142 };
 143
 144 static int __init nf_tables_netdev_init(void)
 145 {
 146         int ret;
 147
 148         ret = nft_register_chain_type(&nft_filter_chain_netdev);
 149         if (ret)
 150                 return ret;
 151
 152         ret = register_pernet_subsys(&nf_tables_netdev_net_ops);
 153         if (ret)
 154                 goto err1;
 155
 156         ret = register_netdevice_notifier(&nf_tables_netdev_notifier);
 157         if (ret)
 158                 goto err2;
 159
 160         return 0;
 161
 162 err2:
 163         unregister_pernet_subsys(&nf_tables_netdev_net_ops);
 164 err1:
 165         nft_unregister_chain_type(&nft_filter_chain_netdev);
 166         return ret;
 167 }
 168
 169 static void __exit nf_tables_netdev_exit(void)
 170 {
 171         unregister_netdevice_notifier(&nf_tables_netdev_notifier);
 172         unregister_pernet_subsys(&nf_tables_netdev_net_ops);
 173         nft_unregister_chain_type(&nft_filter_chain_netdev);
 174 }
 175
 176 module_init(nf_tables_netdev_init);
 177 module_exit(nf_tables_netdev_exit);
 178
 179 MODULE_LICENSE("GPL");
 180 MODULE_AUTHOR("Pablo Neira Ayuso <pablo@netfilter.org>");
 181 MODULE_ALIAS_NFT_FAMILY(5); /* NFPROTO_NETDEV */