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, 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                         module_put(THIS_MODULE);
 171                 }
 172         }
 173 }
 174
 175 #if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
 176 static void l2tp_eth_show(struct seq_file *m, void *arg)
 177 {
 178         struct l2tp_session *session = arg;
 179         struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
 180         struct net_device *dev = spriv->dev;
 181
 182         seq_printf(m, "   interface %s\n", dev->name);
 183 }
 184 #endif
 185
 186 static int l2tp_eth_create(struct net *net, struct l2tp_tunnel *tunnel,
 187                            u32 session_id, u32 peer_session_id,
 188                            struct l2tp_session_cfg *cfg)
 189 {
 190         struct net_device *dev;
 191         char name[IFNAMSIZ];
 192         struct l2tp_session *session;
 193         struct l2tp_eth *priv;
 194         struct l2tp_eth_sess *spriv;
 195         int rc;
 196         struct l2tp_eth_net *pn;
 197
 198         if (cfg->ifname) {
 199                 dev = dev_get_by_name(net, cfg->ifname);
 200                 if (dev) {
 201                         dev_put(dev);
 202                         rc = -EEXIST;
 203                         goto out;
 204                 }
 205                 strlcpy(name, cfg->ifname, IFNAMSIZ);
 206         } else
 207                 strcpy(name, L2TP_ETH_DEV_NAME);
 208
 209         session = l2tp_session_create(sizeof(*spriv), tunnel, session_id,
 210                                       peer_session_id, cfg);
 211         if (IS_ERR(session)) {
 212                 rc = PTR_ERR(session);
 213                 goto out;
 214         }
 215
 216         dev = alloc_netdev(sizeof(*priv), name, l2tp_eth_dev_setup);
 217         if (!dev) {
 218                 rc = -ENOMEM;
 219                 goto out_del_session;
 220         }
 221
 222         dev_net_set(dev, net);
 223         if (session->mtu == 0)
 224                 session->mtu = dev->mtu - session->hdr_len;
 225         dev->mtu = session->mtu;
 226         dev->needed_headroom += session->hdr_len;
 227
 228         priv = netdev_priv(dev);
 229         priv->dev = dev;
 230         priv->session = session;
 231         INIT_LIST_HEAD(&priv->list);
 232
 233         priv->tunnel_sock = tunnel->sock;
 234         session->recv_skb = l2tp_eth_dev_recv;
 235         session->session_close = l2tp_eth_delete;
 236 #if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
 237         session->show = l2tp_eth_show;
 238 #endif
 239
 240         spriv = l2tp_session_priv(session);
 241         spriv->dev = dev;
 242
 243         rc = register_netdev(dev);
 244         if (rc < 0)
 245                 goto out_del_dev;
 246
 247         __module_get(THIS_MODULE);
 248         /* Must be done after register_netdev() */
 249         strlcpy(session->ifname, dev->name, IFNAMSIZ);
 250
 251         dev_hold(dev);
 252         pn = l2tp_eth_pernet(dev_net(dev));
 253         spin_lock(&pn->l2tp_eth_lock);
 254         list_add(&priv->list, &pn->l2tp_eth_dev_list);
 255         spin_unlock(&pn->l2tp_eth_lock);
 256
 257         return 0;
 258
 259 out_del_dev:
 260         free_netdev(dev);
 261         spriv->dev = NULL;
 262 out_del_session:
 263         l2tp_session_delete(session);
 264 out:
 265         return rc;
 266 }
 267
 268 static __net_init int l2tp_eth_init_net(struct net *net)
 269 {
 270         struct l2tp_eth_net *pn = net_generic(net, l2tp_eth_net_id);
 271
 272         INIT_LIST_HEAD(&pn->l2tp_eth_dev_list);
 273         spin_lock_init(&pn->l2tp_eth_lock);
 274
 275         return 0;
 276 }
 277
 278 static struct pernet_operations l2tp_eth_net_ops = {
 279         .init = l2tp_eth_init_net,
 280         .id   = &l2tp_eth_net_id,
 281         .size = sizeof(struct l2tp_eth_net),
 282 };
 283
 284
 285 static const struct l2tp_nl_cmd_ops l2tp_eth_nl_cmd_ops = {
 286         .session_create = l2tp_eth_create,
 287         .session_delete = l2tp_session_delete,
 288 };
 289
 290
 291 static int __init l2tp_eth_init(void)
 292 {
 293         int err = 0;
 294
 295         err = l2tp_nl_register_ops(L2TP_PWTYPE_ETH, &l2tp_eth_nl_cmd_ops);
 296         if (err)
 297                 goto out;
 298
 299         err = register_pernet_device(&l2tp_eth_net_ops);
 300         if (err)
 301                 goto out_unreg;
 302
 303         printk(KERN_INFO "L2TP ethernet pseudowire support (L2TPv3)\n");
 304
 305         return 0;
 306
 307 out_unreg:
 308         l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH);
 309 out:
 310         return err;
 311 }
 312
 313 static void __exit l2tp_eth_exit(void)
 314 {
 315         unregister_pernet_device(&l2tp_eth_net_ops);
 316         l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH);
 317 }
 318
 319 module_init(l2tp_eth_init);
 320 module_exit(l2tp_eth_exit);
 321
 322 MODULE_LICENSE("GPL");
 323 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
 324 MODULE_DESCRIPTION("L2TP ethernet pseudowire driver");
 325 MODULE_VERSION("1.0");