net/l2tp/l2tp_eth.c

   1 /*
   2  * L2TPv3 ethernet pseudowire driver
   3  *
   4  * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
   5  *
   6  *      This program is free software; you can redistribute it and/or
   7  *      modify it under the terms of the GNU General Public License
   8  *      as published by the Free Software Foundation; either version
   9  *      2 of the License, or (at your option) any later version.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/skbuff.h>
  14 #include <linux/socket.h>
  15 #include <linux/hash.h>
  16 #include <linux/l2tp.h>
  17 #include <linux/in.h>
  18 #include <linux/etherdevice.h>
  19 #include <linux/spinlock.h>
  20 #include <net/sock.h>
  21 #include <net/ip.h>
  22 #include <net/icmp.h>
  23 #include <net/udp.h>
  24 #include <net/inet_common.h>
  25 #include <net/inet_hashtables.h>
  26 #include <net/tcp_states.h>
  27 #include <net/protocol.h>
  28 #include <net/xfrm.h>
  29 #include <net/net_namespace.h>
  30 #include <net/netns/generic.h>
  31
  32 #include "l2tp_core.h"
  33
  34 /* Default device name. May be overridden by name specified by user */
  35 #define L2TP_ETH_DEV_NAME       "l2tpeth%d"
  36
  37 /* via netdev_priv() */
  38 struct l2tp_eth {
  39         struct net_device       *dev;
  40         struct sock             *tunnel_sock;
  41         struct l2tp_session     *session;
  42         struct list_head        list;
  43 };
  44
  45 /* via l2tp_session_priv() */
  46 struct l2tp_eth_sess {
  47         struct net_device       *dev;
  48 };
  49
  50 /* per-net private data for this module */
  51 static unsigned int l2tp_eth_net_id;
  52 struct l2tp_eth_net {
  53         struct list_head l2tp_eth_dev_list;
  54         spinlock_t l2tp_eth_lock;
  55 };
  56
  57 static inline struct l2tp_eth_net *l2tp_eth_pernet(struct net *net)
  58 {
  59         return net_generic(net, l2tp_eth_net_id);
  60 }
  61
  62 static int l2tp_eth_dev_init(struct net_device *dev)
  63 {
  64         struct l2tp_eth *priv = netdev_priv(dev);
  65
  66         priv->dev = dev;
  67         random_ether_addr(dev->dev_addr);
  68         memset(&dev->broadcast[0], 0xff, 6);
  69
  70         return 0;
  71 }
  72
  73 static void l2tp_eth_dev_uninit(struct net_device *dev)
  74 {
  75         struct l2tp_eth *priv = netdev_priv(dev);
  76         struct l2tp_eth_net *pn = l2tp_eth_pernet(dev_net(dev));
  77
  78         spin_lock(&pn->l2tp_eth_lock);
  79         list_del_init(&priv->list);
  80         spin_unlock(&pn->l2tp_eth_lock);
  81         dev_put(dev);
  82 }
  83
  84 static int l2tp_eth_dev_xmit(struct sk_buff *skb, struct net_device *dev)
  85 {
  86         struct l2tp_eth *priv = netdev_priv(dev);
  87         struct l2tp_session *session = priv->session;
  88
  89         l2tp_xmit_skb(session, skb, session->hdr_len);
  90
  91         dev->stats.tx_bytes += skb->len;
  92         dev->stats.tx_packets++;
  93
  94         return 0;
  95 }
  96
  97 static struct net_device_ops l2tp_eth_netdev_ops = {
  98         .ndo_init               = l2tp_eth_dev_init,
  99         .ndo_uninit             = l2tp_eth_dev_uninit,
 100         .ndo_start_xmit         = l2tp_eth_dev_xmit,
 101 };
 102
 103 static void l2tp_eth_dev_setup(struct net_device *dev)
 104 {
 105         ether_setup(dev);
 106         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
 107         dev->netdev_ops         = &l2tp_eth_netdev_ops;
 108         dev->destructor         = free_netdev;
 109 }
 110
 111 static void l2tp_eth_dev_recv(struct l2tp_session *session, struct sk_buff *skb, int data_len)
 112 {
 113         struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
 114         struct net_device *dev = spriv->dev;
 115
 116         if (session->debug & L2TP_MSG_DATA) {
 117                 unsigned int length;
 118                 int offset;
 119                 u8 *ptr = skb->data;
 120
 121                 length = min(32u, skb->len);
 122                 if (!pskb_may_pull(skb, length))
 123                         goto error;
 124
 125                 printk(KERN_DEBUG "%s: eth recv: ", session->name);
 126
 127                 offset = 0;
 128                 do {
 129                         printk(" %02X", ptr[offset]);
 130                 } while (++offset < length);
 131
 132                 printk("\n");
 133         }
 134
 135         if (!pskb_may_pull(skb, sizeof(ETH_HLEN)))
 136                 goto error;
 137
 138         secpath_reset(skb);
 139
 140         /* checksums verified by L2TP */
 141         skb->ip_summed = CHECKSUM_NONE;
 142
 143         skb_dst_drop(skb);
 144         nf_reset(skb);
 145
 146         if (dev_forward_skb(dev, skb) == NET_RX_SUCCESS) {
 147                 dev->stats.rx_packets++;
 148                 dev->stats.rx_bytes += data_len;
 149         } else
 150                 dev->stats.rx_errors++;
 151
 152         return;
 153
 154 error:
 155         dev->stats.rx_errors++;
 156         kfree_skb(skb);
 157 }
 158
 159 static void l2tp_eth_delete(struct l2tp_session *session)
 160 {
 161         struct l2tp_eth_sess *spriv;
 162         struct net_device *dev;
 163
 164         if (session) {
 165                 spriv = l2tp_session_priv(session);
 166                 dev = spriv->dev;
 167                 if (dev) {
 168                         unregister_netdev(dev);
 169                         spriv->dev = NULL;
 170                 }
 171         }
 172 }
 173
 174 #if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
 175 static void l2tp_eth_show(struct seq_file *m, void *arg)
 176 {
 177         struct l2tp_session *session = arg;
 178         struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
 179         struct net_device *dev = spriv->dev;
 180
 181         seq_printf(m, "   interface %s\n", dev->name);
 182 }
 183 #endif
 184
 185 static int l2tp_eth_create(struct net *net, u32 tunnel_id, u32 session_id, u32 peer_session_id, struct l2tp_session_cfg *cfg)
 186 {
 187         struct net_device *dev;
 188         char name[IFNAMSIZ];
 189         struct l2tp_tunnel *tunnel;
 190         struct l2tp_session *session;
 191         struct l2tp_eth *priv;
 192         struct l2tp_eth_sess *spriv;
 193         int rc;
 194         struct l2tp_eth_net *pn;
 195
 196         tunnel = l2tp_tunnel_find(net, tunnel_id);
 197         if (!tunnel) {
 198                 rc = -ENODEV;
 199                 goto out;
 200         }
 201
 202         session = l2tp_session_find(net, tunnel, session_id);
 203         if (session) {
 204                 rc = -EEXIST;
 205                 goto out;
 206         }
 207
 208         if (cfg->ifname) {
 209                 dev = dev_get_by_name(net, cfg->ifname);
 210                 if (dev) {
 211                         dev_put(dev);
 212                         rc = -EEXIST;
 213                         goto out;
 214                 }
 215                 strlcpy(name, cfg->ifname, IFNAMSIZ);
 216         } else
 217                 strcpy(name, L2TP_ETH_DEV_NAME);
 218
 219         session = l2tp_session_create(sizeof(*spriv), tunnel, session_id,
 220                                       peer_session_id, cfg);
 221         if (!session) {
 222                 rc = -ENOMEM;
 223                 goto out;
 224         }
 225
 226         dev = alloc_netdev(sizeof(*priv), name, l2tp_eth_dev_setup);
 227         if (!dev) {
 228                 rc = -ENOMEM;
 229                 goto out_del_session;
 230         }
 231
 232         dev_net_set(dev, net);
 233         if (session->mtu == 0)
 234                 session->mtu = dev->mtu - session->hdr_len;
 235         dev->mtu = session->mtu;
 236         dev->needed_headroom += session->hdr_len;
 237
 238         priv = netdev_priv(dev);
 239         priv->dev = dev;
 240         priv->session = session;
 241         INIT_LIST_HEAD(&priv->list);
 242
 243         priv->tunnel_sock = tunnel->sock;
 244         session->recv_skb = l2tp_eth_dev_recv;
 245         session->session_close = l2tp_eth_delete;
 246 #if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
 247         session->show = l2tp_eth_show;
 248 #endif
 249
 250         spriv = l2tp_session_priv(session);
 251         spriv->dev = dev;
 252
 253         rc = register_netdev(dev);
 254         if (rc < 0)
 255                 goto out_del_dev;
 256
 257         /* Must be done after register_netdev() */
 258         strlcpy(session->ifname, dev->name, IFNAMSIZ);
 259
 260         dev_hold(dev);
 261         pn = l2tp_eth_pernet(dev_net(dev));
 262         spin_lock(&pn->l2tp_eth_lock);
 263         list_add(&priv->list, &pn->l2tp_eth_dev_list);
 264         spin_unlock(&pn->l2tp_eth_lock);
 265
 266         return 0;
 267
 268 out_del_dev:
 269         free_netdev(dev);
 270 out_del_session:
 271         l2tp_session_delete(session);
 272 out:
 273         return rc;
 274 }
 275
 276 static __net_init int l2tp_eth_init_net(struct net *net)
 277 {
 278         struct l2tp_eth_net *pn = net_generic(net, l2tp_eth_net_id);
 279
 280         INIT_LIST_HEAD(&pn->l2tp_eth_dev_list);
 281         spin_lock_init(&pn->l2tp_eth_lock);
 282
 283         return 0;
 284 }
 285
 286 static struct pernet_operations l2tp_eth_net_ops = {
 287         .init = l2tp_eth_init_net,
 288         .id   = &l2tp_eth_net_id,
 289         .size = sizeof(struct l2tp_eth_net),
 290 };
 291
 292
 293 static const struct l2tp_nl_cmd_ops l2tp_eth_nl_cmd_ops = {
 294         .session_create = l2tp_eth_create,
 295         .session_delete = l2tp_session_delete,
 296 };
 297
 298
 299 static int __init l2tp_eth_init(void)
 300 {
 301         int err = 0;
 302
 303         err = l2tp_nl_register_ops(L2TP_PWTYPE_ETH, &l2tp_eth_nl_cmd_ops);
 304         if (err)
 305                 goto out;
 306
 307         err = register_pernet_device(&l2tp_eth_net_ops);
 308         if (err)
 309                 goto out_unreg;
 310
 311         printk(KERN_INFO "L2TP ethernet pseudowire support (L2TPv3)\n");
 312
 313         return 0;
 314
 315 out_unreg:
 316         l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH);
 317 out:
 318         return err;
 319 }
 320
 321 static void __exit l2tp_eth_exit(void)
 322 {
 323         unregister_pernet_device(&l2tp_eth_net_ops);
 324         l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH);
 325 }
 326
 327 module_init(l2tp_eth_init);
 328 module_exit(l2tp_eth_exit);
 329
 330 MODULE_LICENSE("GPL");
 331 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
 332 MODULE_DESCRIPTION("L2TP ethernet pseudowire driver");
 333 MODULE_VERSION("1.0");