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 };
  43
  44 /* via l2tp_session_priv() */
  45 struct l2tp_eth_sess {
  46         struct net_device       *dev;
  47 };
  48
  49
  50 static int l2tp_eth_dev_init(struct net_device *dev)
  51 {
  52         struct l2tp_eth *priv = netdev_priv(dev);
  53
  54         priv->dev = dev;
  55         random_ether_addr(dev->dev_addr);
  56         memset(&dev->broadcast[0], 0xff, 6);
  57
  58         return 0;
  59 }
  60
  61 static void l2tp_eth_dev_uninit(struct net_device *dev)
  62 {
  63         dev_put(dev);
  64 }
  65
  66 static int l2tp_eth_dev_xmit(struct sk_buff *skb, struct net_device *dev)
  67 {
  68         struct l2tp_eth *priv = netdev_priv(dev);
  69         struct l2tp_session *session = priv->session;
  70
  71         l2tp_xmit_skb(session, skb, session->hdr_len);
  72
  73         dev->stats.tx_bytes += skb->len;
  74         dev->stats.tx_packets++;
  75
  76         return 0;
  77 }
  78
  79 static struct net_device_ops l2tp_eth_netdev_ops = {
  80         .ndo_init               = l2tp_eth_dev_init,
  81         .ndo_uninit             = l2tp_eth_dev_uninit,
  82         .ndo_start_xmit         = l2tp_eth_dev_xmit,
  83 };
  84
  85 static void l2tp_eth_dev_setup(struct net_device *dev)
  86 {
  87         ether_setup(dev);
  88         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
  89         dev->netdev_ops         = &l2tp_eth_netdev_ops;
  90         dev->destructor         = free_netdev;
  91 }
  92
  93 static void l2tp_eth_dev_recv(struct l2tp_session *session, struct sk_buff *skb, int data_len)
  94 {
  95         struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
  96         struct net_device *dev = spriv->dev;
  97
  98         if (session->debug & L2TP_MSG_DATA) {
  99                 unsigned int length;
 100                 int offset;
 101                 u8 *ptr = skb->data;
 102
 103                 length = min(32u, skb->len);
 104                 if (!pskb_may_pull(skb, length))
 105                         goto error;
 106
 107                 printk(KERN_DEBUG "%s: eth recv: ", session->name);
 108
 109                 offset = 0;
 110                 do {
 111                         printk(" %02X", ptr[offset]);
 112                 } while (++offset < length);
 113
 114                 printk("\n");
 115         }
 116
 117         if (!pskb_may_pull(skb, ETH_HLEN))
 118                 goto error;
 119
 120         secpath_reset(skb);
 121
 122         /* checksums verified by L2TP */
 123         skb->ip_summed = CHECKSUM_NONE;
 124
 125         skb_dst_drop(skb);
 126         nf_reset(skb);
 127
 128         if (dev_forward_skb(dev, skb) == NET_RX_SUCCESS) {
 129                 dev->stats.rx_packets++;
 130                 dev->stats.rx_bytes += data_len;
 131         } else
 132                 dev->stats.rx_errors++;
 133
 134         return;
 135
 136 error:
 137         dev->stats.rx_errors++;
 138         kfree_skb(skb);
 139 }
 140
 141 static void l2tp_eth_delete(struct l2tp_session *session)
 142 {
 143         struct l2tp_eth_sess *spriv;
 144         struct net_device *dev;
 145
 146         if (session) {
 147                 spriv = l2tp_session_priv(session);
 148                 dev = spriv->dev;
 149                 if (dev) {
 150                         unregister_netdev(dev);
 151                         spriv->dev = NULL;
 152                         module_put(THIS_MODULE);
 153                 }
 154         }
 155 }
 156
 157 #if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
 158 static void l2tp_eth_show(struct seq_file *m, void *arg)
 159 {
 160         struct l2tp_session *session = arg;
 161         struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
 162         struct net_device *dev = spriv->dev;
 163
 164         seq_printf(m, "   interface %s\n", dev->name);
 165 }
 166 #endif
 167
 168 static int l2tp_eth_create(struct net *net, struct l2tp_tunnel *tunnel,
 169                            u32 session_id, u32 peer_session_id,
 170                            struct l2tp_session_cfg *cfg)
 171 {
 172         struct net_device *dev;
 173         char name[IFNAMSIZ];
 174         struct l2tp_session *session;
 175         struct l2tp_eth *priv;
 176         struct l2tp_eth_sess *spriv;
 177         int rc;
 178
 179         if (cfg->ifname) {
 180                 dev = dev_get_by_name(net, cfg->ifname);
 181                 if (dev) {
 182                         dev_put(dev);
 183                         rc = -EEXIST;
 184                         goto out;
 185                 }
 186                 strlcpy(name, cfg->ifname, IFNAMSIZ);
 187         } else
 188                 strcpy(name, L2TP_ETH_DEV_NAME);
 189
 190         session = l2tp_session_create(sizeof(*spriv), tunnel, session_id,
 191                                       peer_session_id, cfg);
 192         if (IS_ERR(session)) {
 193                 rc = PTR_ERR(session);
 194                 goto out;
 195         }
 196
 197         l2tp_session_inc_refcount(session);
 198         rc = l2tp_session_register(session, tunnel);
 199         if (rc < 0) {
 200                 kfree(session);
 201                 goto out;
 202         }
 203
 204         dev = alloc_netdev(sizeof(*priv), name, l2tp_eth_dev_setup);
 205         if (!dev) {
 206                 rc = -ENOMEM;
 207                 goto out_del_session;
 208         }
 209
 210         dev_net_set(dev, net);
 211         if (session->mtu == 0)
 212                 session->mtu = dev->mtu - session->hdr_len;
 213         dev->mtu = session->mtu;
 214         dev->needed_headroom += session->hdr_len;
 215
 216         priv = netdev_priv(dev);
 217         priv->dev = dev;
 218         priv->session = session;
 219
 220         priv->tunnel_sock = tunnel->sock;
 221         session->recv_skb = l2tp_eth_dev_recv;
 222         session->session_close = l2tp_eth_delete;
 223 #if defined(CONFIG_L2TP_DEBUGFS) || defined(CONFIG_L2TP_DEBUGFS_MODULE)
 224         session->show = l2tp_eth_show;
 225 #endif
 226
 227         spriv = l2tp_session_priv(session);
 228         spriv->dev = dev;
 229
 230         rc = register_netdev(dev);
 231         if (rc < 0)
 232                 goto out_del_dev;
 233
 234         __module_get(THIS_MODULE);
 235         /* Must be done after register_netdev() */
 236         strlcpy(session->ifname, dev->name, IFNAMSIZ);
 237         l2tp_session_dec_refcount(session);
 238
 239         dev_hold(dev);
 240
 241         return 0;
 242
 243 out_del_dev:
 244         free_netdev(dev);
 245         spriv->dev = NULL;
 246 out_del_session:
 247         l2tp_session_delete(session);
 248         l2tp_session_dec_refcount(session);
 249 out:
 250         return rc;
 251 }
 252
 253
 254 static const struct l2tp_nl_cmd_ops l2tp_eth_nl_cmd_ops = {
 255         .session_create = l2tp_eth_create,
 256         .session_delete = l2tp_session_delete,
 257 };
 258
 259
 260 static int __init l2tp_eth_init(void)
 261 {
 262         int err = 0;
 263
 264         err = l2tp_nl_register_ops(L2TP_PWTYPE_ETH, &l2tp_eth_nl_cmd_ops);
 265         if (err)
 266                 goto err;
 267
 268         printk(KERN_INFO "L2TP ethernet pseudowire support (L2TPv3)\n");
 269
 270         return 0;
 271
 272 err:
 273         return err;
 274 }
 275
 276 static void __exit l2tp_eth_exit(void)
 277 {
 278         l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH);
 279 }
 280
 281 module_init(l2tp_eth_init);
 282 module_exit(l2tp_eth_exit);
 283
 284 MODULE_LICENSE("GPL");
 285 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
 286 MODULE_DESCRIPTION("L2TP ethernet pseudowire driver");
 287 MODULE_VERSION("1.0");