1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* L2TPv3 ethernet pseudowire driver
3  *
4  * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
5  */
6 
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8 
9 #include <linux/module.h>
10 #include <linux/skbuff.h>
11 #include <linux/socket.h>
12 #include <linux/hash.h>
13 #include <linux/l2tp.h>
14 #include <linux/in.h>
15 #include <linux/etherdevice.h>
16 #include <linux/spinlock.h>
17 #include <net/sock.h>
18 #include <net/ip.h>
19 #include <net/icmp.h>
20 #include <net/udp.h>
21 #include <net/inet_common.h>
22 #include <net/inet_hashtables.h>
23 #include <net/tcp_states.h>
24 #include <net/protocol.h>
25 #include <net/xfrm.h>
26 #include <net/net_namespace.h>
27 #include <net/netns/generic.h>
28 #include <linux/ip.h>
29 #include <linux/ipv6.h>
30 #include <linux/udp.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 l2tp_session	*session;
40 };
41 
42 /* via l2tp_session_priv() */
43 struct l2tp_eth_sess {
44 	struct net_device __rcu *dev;
45 };
46 
l2tp_eth_dev_init(struct net_device * dev)47 static int l2tp_eth_dev_init(struct net_device *dev)
48 {
49 	eth_hw_addr_random(dev);
50 	eth_broadcast_addr(dev->broadcast);
51 	netdev_lockdep_set_classes(dev);
52 
53 	return 0;
54 }
55 
l2tp_eth_dev_uninit(struct net_device * dev)56 static void l2tp_eth_dev_uninit(struct net_device *dev)
57 {
58 	struct l2tp_eth *priv = netdev_priv(dev);
59 	struct l2tp_eth_sess *spriv;
60 
61 	spriv = l2tp_session_priv(priv->session);
62 	RCU_INIT_POINTER(spriv->dev, NULL);
63 	/* No need for synchronize_net() here. We're called by
64 	 * unregister_netdev*(), which does the synchronisation for us.
65 	 */
66 }
67 
l2tp_eth_dev_xmit(struct sk_buff * skb,struct net_device * dev)68 static netdev_tx_t l2tp_eth_dev_xmit(struct sk_buff *skb, struct net_device *dev)
69 {
70 	struct l2tp_eth *priv = netdev_priv(dev);
71 	struct l2tp_session *session = priv->session;
72 	unsigned int len = skb->len;
73 	int ret = l2tp_xmit_skb(session, skb);
74 
75 	if (likely(ret == NET_XMIT_SUCCESS))
76 		dev_dstats_tx_add(dev, len);
77 	else
78 		dev_dstats_tx_dropped(dev);
79 
80 	return NETDEV_TX_OK;
81 }
82 
83 static const struct net_device_ops l2tp_eth_netdev_ops = {
84 	.ndo_init		= l2tp_eth_dev_init,
85 	.ndo_uninit		= l2tp_eth_dev_uninit,
86 	.ndo_start_xmit		= l2tp_eth_dev_xmit,
87 	.ndo_set_mac_address	= eth_mac_addr,
88 };
89 
90 static const struct device_type l2tpeth_type = {
91 	.name = "l2tpeth",
92 };
93 
l2tp_eth_dev_setup(struct net_device * dev)94 static void l2tp_eth_dev_setup(struct net_device *dev)
95 {
96 	SET_NETDEV_DEVTYPE(dev, &l2tpeth_type);
97 	ether_setup(dev);
98 	dev->priv_flags		&= ~IFF_TX_SKB_SHARING;
99 	dev->lltx		= true;
100 	dev->netdev_ops		= &l2tp_eth_netdev_ops;
101 	dev->needs_free_netdev	= true;
102 	dev->pcpu_stat_type	= NETDEV_PCPU_STAT_DSTATS;
103 }
104 
l2tp_eth_dev_recv(struct l2tp_session * session,struct sk_buff * skb,int data_len)105 static void l2tp_eth_dev_recv(struct l2tp_session *session, struct sk_buff *skb, int data_len)
106 {
107 	struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
108 	struct net_device *dev;
109 
110 	if (!pskb_may_pull(skb, ETH_HLEN))
111 		goto error;
112 
113 	secpath_reset(skb);
114 
115 	/* checksums verified by L2TP */
116 	skb->ip_summed = CHECKSUM_NONE;
117 
118 	/* drop outer flow-hash */
119 	skb_clear_hash(skb);
120 
121 	skb_dst_drop(skb);
122 	nf_reset_ct(skb);
123 
124 	rcu_read_lock();
125 	dev = rcu_dereference(spriv->dev);
126 	if (!dev)
127 		goto error_rcu;
128 
129 	if (dev_forward_skb(dev, skb) == NET_RX_SUCCESS)
130 		dev_dstats_rx_add(dev, data_len);
131 	else
132 		DEV_STATS_INC(dev, rx_errors);
133 
134 	rcu_read_unlock();
135 
136 	return;
137 
138 error_rcu:
139 	rcu_read_unlock();
140 error:
141 	kfree_skb(skb);
142 }
143 
l2tp_eth_delete(struct l2tp_session * session)144 static void l2tp_eth_delete(struct l2tp_session *session)
145 {
146 	struct l2tp_eth_sess *spriv;
147 	struct net_device *dev;
148 
149 	if (session) {
150 		spriv = l2tp_session_priv(session);
151 
152 		rtnl_lock();
153 		dev = rtnl_dereference(spriv->dev);
154 		if (dev) {
155 			unregister_netdevice(dev);
156 			rtnl_unlock();
157 			module_put(THIS_MODULE);
158 		} else {
159 			rtnl_unlock();
160 		}
161 	}
162 }
163 
l2tp_eth_show(struct seq_file * m,void * arg)164 static void l2tp_eth_show(struct seq_file *m, void *arg)
165 {
166 	struct l2tp_session *session = arg;
167 	struct l2tp_eth_sess *spriv = l2tp_session_priv(session);
168 	struct net_device *dev;
169 
170 	rcu_read_lock();
171 	dev = rcu_dereference(spriv->dev);
172 	if (!dev) {
173 		rcu_read_unlock();
174 		return;
175 	}
176 	dev_hold(dev);
177 	rcu_read_unlock();
178 
179 	seq_printf(m, "   interface %s\n", dev->name);
180 
181 	dev_put(dev);
182 }
183 
l2tp_eth_adjust_mtu(struct l2tp_tunnel * tunnel,struct l2tp_session * session,struct net_device * dev)184 static void l2tp_eth_adjust_mtu(struct l2tp_tunnel *tunnel,
185 				struct l2tp_session *session,
186 				struct net_device *dev)
187 {
188 	unsigned int overhead = 0;
189 	u32 l3_overhead = 0;
190 	u32 mtu;
191 
192 	/* if the encap is UDP, account for UDP header size */
193 	if (tunnel->encap == L2TP_ENCAPTYPE_UDP) {
194 		overhead += sizeof(struct udphdr);
195 		dev->needed_headroom += sizeof(struct udphdr);
196 	}
197 
198 	lock_sock(tunnel->sock);
199 	l3_overhead = kernel_sock_ip_overhead(tunnel->sock);
200 	release_sock(tunnel->sock);
201 
202 	if (l3_overhead == 0) {
203 		/* L3 Overhead couldn't be identified, this could be
204 		 * because tunnel->sock was NULL or the socket's
205 		 * address family was not IPv4 or IPv6,
206 		 * dev mtu stays at 1500.
207 		 */
208 		return;
209 	}
210 	/* Adjust MTU, factor overhead - underlay L3, overlay L2 hdr
211 	 * UDP overhead, if any, was already factored in above.
212 	 */
213 	overhead += session->hdr_len + ETH_HLEN + l3_overhead;
214 
215 	mtu = l2tp_tunnel_dst_mtu(tunnel) - overhead;
216 	if (mtu < dev->min_mtu || mtu > dev->max_mtu)
217 		dev->mtu = ETH_DATA_LEN - overhead;
218 	else
219 		dev->mtu = mtu;
220 
221 	dev->needed_headroom += session->hdr_len;
222 }
223 
l2tp_eth_create(struct net * net,struct l2tp_tunnel * tunnel,u32 session_id,u32 peer_session_id,struct l2tp_session_cfg * cfg)224 static int l2tp_eth_create(struct net *net, struct l2tp_tunnel *tunnel,
225 			   u32 session_id, u32 peer_session_id,
226 			   struct l2tp_session_cfg *cfg)
227 {
228 	unsigned char name_assign_type;
229 	struct net_device *dev;
230 	char name[IFNAMSIZ];
231 	struct l2tp_session *session;
232 	struct l2tp_eth *priv;
233 	struct l2tp_eth_sess *spriv;
234 	int rc;
235 
236 	if (cfg->ifname) {
237 		strscpy(name, cfg->ifname, IFNAMSIZ);
238 		name_assign_type = NET_NAME_USER;
239 	} else {
240 		strcpy(name, L2TP_ETH_DEV_NAME);
241 		name_assign_type = NET_NAME_ENUM;
242 	}
243 
244 	session = l2tp_session_create(sizeof(*spriv), tunnel, session_id,
245 				      peer_session_id, cfg);
246 	if (IS_ERR(session)) {
247 		rc = PTR_ERR(session);
248 		goto err;
249 	}
250 
251 	dev = alloc_netdev(sizeof(*priv), name, name_assign_type,
252 			   l2tp_eth_dev_setup);
253 	if (!dev) {
254 		rc = -ENOMEM;
255 		goto err_sess;
256 	}
257 
258 	dev_net_set(dev, net);
259 	dev->min_mtu = 0;
260 	dev->max_mtu = ETH_MAX_MTU;
261 	l2tp_eth_adjust_mtu(tunnel, session, dev);
262 
263 	priv = netdev_priv(dev);
264 	priv->session = session;
265 
266 	session->recv_skb = l2tp_eth_dev_recv;
267 	session->session_close = l2tp_eth_delete;
268 	if (IS_ENABLED(CONFIG_L2TP_DEBUGFS))
269 		session->show = l2tp_eth_show;
270 
271 	spriv = l2tp_session_priv(session);
272 
273 	refcount_inc(&session->ref_count);
274 
275 	rtnl_lock();
276 
277 	/* Register both device and session while holding the rtnl lock. This
278 	 * ensures that l2tp_eth_delete() will see that there's a device to
279 	 * unregister, even if it happened to run before we assign spriv->dev.
280 	 */
281 	rc = l2tp_session_register(session, tunnel);
282 	if (rc < 0) {
283 		rtnl_unlock();
284 		goto err_sess_dev;
285 	}
286 
287 	rc = register_netdevice(dev);
288 	if (rc < 0) {
289 		rtnl_unlock();
290 		l2tp_session_delete(session);
291 		l2tp_session_put(session);
292 		free_netdev(dev);
293 
294 		return rc;
295 	}
296 
297 	strscpy(session->ifname, dev->name, IFNAMSIZ);
298 	rcu_assign_pointer(spriv->dev, dev);
299 
300 	rtnl_unlock();
301 
302 	l2tp_session_put(session);
303 
304 	__module_get(THIS_MODULE);
305 
306 	return 0;
307 
308 err_sess_dev:
309 	l2tp_session_put(session);
310 	free_netdev(dev);
311 err_sess:
312 	l2tp_session_put(session);
313 err:
314 	return rc;
315 }
316 
317 static const struct l2tp_nl_cmd_ops l2tp_eth_nl_cmd_ops = {
318 	.session_create	= l2tp_eth_create,
319 	.session_delete	= l2tp_session_delete,
320 };
321 
l2tp_eth_init(void)322 static int __init l2tp_eth_init(void)
323 {
324 	int err = 0;
325 
326 	err = l2tp_nl_register_ops(L2TP_PWTYPE_ETH, &l2tp_eth_nl_cmd_ops);
327 	if (err)
328 		goto err;
329 
330 	pr_info("L2TP ethernet pseudowire support (L2TPv3)\n");
331 
332 	return 0;
333 
334 err:
335 	return err;
336 }
337 
l2tp_eth_exit(void)338 static void __exit l2tp_eth_exit(void)
339 {
340 	l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH);
341 }
342 
343 module_init(l2tp_eth_init);
344 module_exit(l2tp_eth_exit);
345 
346 MODULE_LICENSE("GPL");
347 MODULE_AUTHOR("James Chapman <[email protected]>");
348 MODULE_DESCRIPTION("L2TP ethernet pseudowire driver");
349 MODULE_VERSION("1.0");
350 MODULE_ALIAS_L2TP_PWTYPE(5);
351