1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 *	"LAPB via ethernet" driver release 001
4 *
5 *	This code REQUIRES 2.1.15 or higher/ NET3.038
6 *
7 *	This is a "pseudo" network driver to allow LAPB over Ethernet.
8 *
9 *	This driver can use any ethernet destination address, and can be
10 *	limited to accept frames from one dedicated ethernet card only.
11 *
12 *	History
13 *	LAPBETH 001	Jonathan Naylor		Cloned from bpqether.c
14 *	2000-10-29	Henner Eisen	lapb_data_indication() return status.
15 *	2000-11-14	Henner Eisen	dev_hold/put, NETDEV_GOING_DOWN support
16 */
17
18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
20#include <linux/errno.h>
21#include <linux/types.h>
22#include <linux/socket.h>
23#include <linux/in.h>
24#include <linux/slab.h>
25#include <linux/kernel.h>
26#include <linux/string.h>
27#include <linux/net.h>
28#include <linux/inet.h>
29#include <linux/netdevice.h>
30#include <linux/if_arp.h>
31#include <linux/skbuff.h>
32#include <net/sock.h>
33#include <linux/uaccess.h>
34#include <linux/mm.h>
35#include <linux/interrupt.h>
36#include <linux/notifier.h>
37#include <linux/stat.h>
38#include <linux/module.h>
39#include <linux/lapb.h>
40#include <linux/init.h>
41
42#include <net/x25device.h>
43
44static const u8 bcast_addr[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
45
46/* If this number is made larger, check that the temporary string buffer
47 * in lapbeth_new_device is large enough to store the probe device name.
48 */
49#define MAXLAPBDEV 100
50
51struct lapbethdev {
52	struct list_head	node;
53	struct net_device	*ethdev;	/* link to ethernet device */
54	struct net_device	*axdev;		/* lapbeth device (lapb#) */
55	bool			up;
56	spinlock_t		up_lock;	/* Protects "up" */
57	struct sk_buff_head	rx_queue;
58	struct napi_struct	napi;
59};
60
61static LIST_HEAD(lapbeth_devices);
62
63static void lapbeth_connected(struct net_device *dev, int reason);
64static void lapbeth_disconnected(struct net_device *dev, int reason);
65
66/* ------------------------------------------------------------------------ */
67
68/*	Get the LAPB device for the ethernet device
69 */
70static struct lapbethdev *lapbeth_get_x25_dev(struct net_device *dev)
71{
72	struct lapbethdev *lapbeth;
73
74	list_for_each_entry_rcu(lapbeth, &lapbeth_devices, node, lockdep_rtnl_is_held()) {
75		if (lapbeth->ethdev == dev)
76			return lapbeth;
77	}
78	return NULL;
79}
80
81static __inline__ int dev_is_ethdev(struct net_device *dev)
82{
83	return dev->type == ARPHRD_ETHER && strncmp(dev->name, "dummy", 5);
84}
85
86/* ------------------------------------------------------------------------ */
87
88static int lapbeth_napi_poll(struct napi_struct *napi, int budget)
89{
90	struct lapbethdev *lapbeth = container_of(napi, struct lapbethdev,
91						  napi);
92	struct sk_buff *skb;
93	int processed = 0;
94
95	for (; processed < budget; ++processed) {
96		skb = skb_dequeue(&lapbeth->rx_queue);
97		if (!skb)
98			break;
99		netif_receive_skb_core(skb);
100	}
101
102	if (processed < budget)
103		napi_complete(napi);
104
105	return processed;
106}
107
108/*	Receive a LAPB frame via an ethernet interface.
109 */
110static int lapbeth_rcv(struct sk_buff *skb, struct net_device *dev,
111		       struct packet_type *ptype, struct net_device *orig_dev)
112{
113	int len, err;
114	struct lapbethdev *lapbeth;
115
116	if (dev_net(dev) != &init_net)
117		goto drop;
118
119	skb = skb_share_check(skb, GFP_ATOMIC);
120	if (!skb)
121		return NET_RX_DROP;
122
123	if (!pskb_may_pull(skb, 2))
124		goto drop;
125
126	rcu_read_lock();
127	lapbeth = lapbeth_get_x25_dev(dev);
128	if (!lapbeth)
129		goto drop_unlock_rcu;
130	spin_lock_bh(&lapbeth->up_lock);
131	if (!lapbeth->up)
132		goto drop_unlock;
133
134	len = skb->data[0] + skb->data[1] * 256;
135	dev->stats.rx_packets++;
136	dev->stats.rx_bytes += len;
137
138	skb_pull(skb, 2);	/* Remove the length bytes */
139	skb_trim(skb, len);	/* Set the length of the data */
140
141	err = lapb_data_received(lapbeth->axdev, skb);
142	if (err != LAPB_OK) {
143		printk(KERN_DEBUG "lapbether: lapb_data_received err - %d\n", err);
144		goto drop_unlock;
145	}
146out:
147	spin_unlock_bh(&lapbeth->up_lock);
148	rcu_read_unlock();
149	return 0;
150drop_unlock:
151	kfree_skb(skb);
152	goto out;
153drop_unlock_rcu:
154	rcu_read_unlock();
155drop:
156	kfree_skb(skb);
157	return 0;
158}
159
160static int lapbeth_data_indication(struct net_device *dev, struct sk_buff *skb)
161{
162	struct lapbethdev *lapbeth = netdev_priv(dev);
163	unsigned char *ptr;
164
165	if (skb_cow(skb, 1)) {
166		kfree_skb(skb);
167		return NET_RX_DROP;
168	}
169
170	skb_push(skb, 1);
171
172	ptr  = skb->data;
173	*ptr = X25_IFACE_DATA;
174
175	skb->protocol = x25_type_trans(skb, dev);
176
177	skb_queue_tail(&lapbeth->rx_queue, skb);
178	napi_schedule(&lapbeth->napi);
179	return NET_RX_SUCCESS;
180}
181
182/*	Send a LAPB frame via an ethernet interface
183 */
184static netdev_tx_t lapbeth_xmit(struct sk_buff *skb,
185				struct net_device *dev)
186{
187	struct lapbethdev *lapbeth = netdev_priv(dev);
188	int err;
189
190	spin_lock_bh(&lapbeth->up_lock);
191	if (!lapbeth->up)
192		goto drop;
193
194	/* There should be a pseudo header of 1 byte added by upper layers.
195	 * Check to make sure it is there before reading it.
196	 */
197	if (skb->len < 1)
198		goto drop;
199
200	switch (skb->data[0]) {
201	case X25_IFACE_DATA:
202		break;
203	case X25_IFACE_CONNECT:
204		err = lapb_connect_request(dev);
205		if (err == LAPB_CONNECTED)
206			lapbeth_connected(dev, LAPB_OK);
207		else if (err != LAPB_OK)
208			pr_err("lapb_connect_request error: %d\n", err);
209		goto drop;
210	case X25_IFACE_DISCONNECT:
211		err = lapb_disconnect_request(dev);
212		if (err == LAPB_NOTCONNECTED)
213			lapbeth_disconnected(dev, LAPB_OK);
214		else if (err != LAPB_OK)
215			pr_err("lapb_disconnect_request err: %d\n", err);
216		fallthrough;
217	default:
218		goto drop;
219	}
220
221	skb_pull(skb, 1);
222
223	err = lapb_data_request(dev, skb);
224	if (err != LAPB_OK) {
225		pr_err("lapb_data_request error - %d\n", err);
226		goto drop;
227	}
228out:
229	spin_unlock_bh(&lapbeth->up_lock);
230	return NETDEV_TX_OK;
231drop:
232	kfree_skb(skb);
233	goto out;
234}
235
236static void lapbeth_data_transmit(struct net_device *ndev, struct sk_buff *skb)
237{
238	struct lapbethdev *lapbeth = netdev_priv(ndev);
239	unsigned char *ptr;
240	struct net_device *dev;
241	int size = skb->len;
242
243	ptr = skb_push(skb, 2);
244
245	*ptr++ = size % 256;
246	*ptr++ = size / 256;
247
248	ndev->stats.tx_packets++;
249	ndev->stats.tx_bytes += size;
250
251	skb->dev = dev = lapbeth->ethdev;
252
253	skb->protocol = htons(ETH_P_DEC);
254
255	skb_reset_network_header(skb);
256
257	dev_hard_header(skb, dev, ETH_P_DEC, bcast_addr, NULL, 0);
258
259	dev_queue_xmit(skb);
260}
261
262static void lapbeth_connected(struct net_device *dev, int reason)
263{
264	struct lapbethdev *lapbeth = netdev_priv(dev);
265	unsigned char *ptr;
266	struct sk_buff *skb = __dev_alloc_skb(1, GFP_ATOMIC | __GFP_NOMEMALLOC);
267
268	if (!skb)
269		return;
270
271	ptr  = skb_put(skb, 1);
272	*ptr = X25_IFACE_CONNECT;
273
274	skb->protocol = x25_type_trans(skb, dev);
275
276	skb_queue_tail(&lapbeth->rx_queue, skb);
277	napi_schedule(&lapbeth->napi);
278}
279
280static void lapbeth_disconnected(struct net_device *dev, int reason)
281{
282	struct lapbethdev *lapbeth = netdev_priv(dev);
283	unsigned char *ptr;
284	struct sk_buff *skb = __dev_alloc_skb(1, GFP_ATOMIC | __GFP_NOMEMALLOC);
285
286	if (!skb)
287		return;
288
289	ptr  = skb_put(skb, 1);
290	*ptr = X25_IFACE_DISCONNECT;
291
292	skb->protocol = x25_type_trans(skb, dev);
293
294	skb_queue_tail(&lapbeth->rx_queue, skb);
295	napi_schedule(&lapbeth->napi);
296}
297
298/*	Set AX.25 callsign
299 */
300static int lapbeth_set_mac_address(struct net_device *dev, void *addr)
301{
302	struct sockaddr *sa = addr;
303
304	dev_addr_set(dev, sa->sa_data);
305	return 0;
306}
307
308static const struct lapb_register_struct lapbeth_callbacks = {
309	.connect_confirmation    = lapbeth_connected,
310	.connect_indication      = lapbeth_connected,
311	.disconnect_confirmation = lapbeth_disconnected,
312	.disconnect_indication   = lapbeth_disconnected,
313	.data_indication         = lapbeth_data_indication,
314	.data_transmit           = lapbeth_data_transmit,
315};
316
317/* open/close a device
318 */
319static int lapbeth_open(struct net_device *dev)
320{
321	struct lapbethdev *lapbeth = netdev_priv(dev);
322	int err;
323
324	napi_enable(&lapbeth->napi);
325
326	err = lapb_register(dev, &lapbeth_callbacks);
327	if (err != LAPB_OK) {
328		napi_disable(&lapbeth->napi);
329		pr_err("lapb_register error: %d\n", err);
330		return -ENODEV;
331	}
332
333	spin_lock_bh(&lapbeth->up_lock);
334	lapbeth->up = true;
335	spin_unlock_bh(&lapbeth->up_lock);
336
337	return 0;
338}
339
340static int lapbeth_close(struct net_device *dev)
341{
342	struct lapbethdev *lapbeth = netdev_priv(dev);
343	int err;
344
345	spin_lock_bh(&lapbeth->up_lock);
346	lapbeth->up = false;
347	spin_unlock_bh(&lapbeth->up_lock);
348
349	err = lapb_unregister(dev);
350	if (err != LAPB_OK)
351		pr_err("lapb_unregister error: %d\n", err);
352
353	napi_disable(&lapbeth->napi);
354
355	return 0;
356}
357
358/* ------------------------------------------------------------------------ */
359
360static const struct net_device_ops lapbeth_netdev_ops = {
361	.ndo_open	     = lapbeth_open,
362	.ndo_stop	     = lapbeth_close,
363	.ndo_start_xmit	     = lapbeth_xmit,
364	.ndo_set_mac_address = lapbeth_set_mac_address,
365};
366
367static void lapbeth_setup(struct net_device *dev)
368{
369	dev->netdev_ops	     = &lapbeth_netdev_ops;
370	dev->needs_free_netdev = true;
371	dev->type            = ARPHRD_X25;
372	dev->hard_header_len = 0;
373	dev->mtu             = 1000;
374	dev->addr_len        = 0;
375}
376
377/*	Setup a new device.
378 */
379static int lapbeth_new_device(struct net_device *dev)
380{
381	struct net_device *ndev;
382	struct lapbethdev *lapbeth;
383	int rc = -ENOMEM;
384
385	ASSERT_RTNL();
386
387	if (dev->type != ARPHRD_ETHER)
388		return -EINVAL;
389
390	ndev = alloc_netdev(sizeof(*lapbeth), "lapb%d", NET_NAME_UNKNOWN,
391			    lapbeth_setup);
392	if (!ndev)
393		goto out;
394
395	/* When transmitting data:
396	 * first this driver removes a pseudo header of 1 byte,
397	 * then the lapb module prepends an LAPB header of at most 3 bytes,
398	 * then this driver prepends a length field of 2 bytes,
399	 * then the underlying Ethernet device prepends its own header.
400	 */
401	ndev->needed_headroom = -1 + 3 + 2 + dev->hard_header_len
402					   + dev->needed_headroom;
403	ndev->needed_tailroom = dev->needed_tailroom;
404
405	lapbeth = netdev_priv(ndev);
406	lapbeth->axdev = ndev;
407
408	dev_hold(dev);
409	lapbeth->ethdev = dev;
410
411	lapbeth->up = false;
412	spin_lock_init(&lapbeth->up_lock);
413
414	skb_queue_head_init(&lapbeth->rx_queue);
415	netif_napi_add_weight(ndev, &lapbeth->napi, lapbeth_napi_poll, 16);
416
417	rc = -EIO;
418	if (register_netdevice(ndev))
419		goto fail;
420
421	list_add_rcu(&lapbeth->node, &lapbeth_devices);
422	rc = 0;
423out:
424	return rc;
425fail:
426	dev_put(dev);
427	free_netdev(ndev);
428	goto out;
429}
430
431/*	Free a lapb network device.
432 */
433static void lapbeth_free_device(struct lapbethdev *lapbeth)
434{
435	dev_put(lapbeth->ethdev);
436	list_del_rcu(&lapbeth->node);
437	unregister_netdevice(lapbeth->axdev);
438}
439
440/*	Handle device status changes.
441 *
442 * Called from notifier with RTNL held.
443 */
444static int lapbeth_device_event(struct notifier_block *this,
445				unsigned long event, void *ptr)
446{
447	struct lapbethdev *lapbeth;
448	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
449
450	if (dev_net(dev) != &init_net)
451		return NOTIFY_DONE;
452
453	if (!dev_is_ethdev(dev) && !lapbeth_get_x25_dev(dev))
454		return NOTIFY_DONE;
455
456	switch (event) {
457	case NETDEV_UP:
458		/* New ethernet device -> new LAPB interface	 */
459		if (!lapbeth_get_x25_dev(dev))
460			lapbeth_new_device(dev);
461		break;
462	case NETDEV_GOING_DOWN:
463		/* ethernet device closes -> close LAPB interface */
464		lapbeth = lapbeth_get_x25_dev(dev);
465		if (lapbeth)
466			dev_close(lapbeth->axdev);
467		break;
468	case NETDEV_UNREGISTER:
469		/* ethernet device disappears -> remove LAPB interface */
470		lapbeth = lapbeth_get_x25_dev(dev);
471		if (lapbeth)
472			lapbeth_free_device(lapbeth);
473		break;
474	}
475
476	return NOTIFY_DONE;
477}
478
479/* ------------------------------------------------------------------------ */
480
481static struct packet_type lapbeth_packet_type __read_mostly = {
482	.type = cpu_to_be16(ETH_P_DEC),
483	.func = lapbeth_rcv,
484};
485
486static struct notifier_block lapbeth_dev_notifier = {
487	.notifier_call = lapbeth_device_event,
488};
489
490static const char banner[] __initconst =
491	KERN_INFO "LAPB Ethernet driver version 0.02\n";
492
493static int __init lapbeth_init_driver(void)
494{
495	dev_add_pack(&lapbeth_packet_type);
496
497	register_netdevice_notifier(&lapbeth_dev_notifier);
498
499	printk(banner);
500
501	return 0;
502}
503module_init(lapbeth_init_driver);
504
505static void __exit lapbeth_cleanup_driver(void)
506{
507	struct lapbethdev *lapbeth;
508	struct list_head *entry, *tmp;
509
510	dev_remove_pack(&lapbeth_packet_type);
511	unregister_netdevice_notifier(&lapbeth_dev_notifier);
512
513	rtnl_lock();
514	list_for_each_safe(entry, tmp, &lapbeth_devices) {
515		lapbeth = list_entry(entry, struct lapbethdev, node);
516
517		dev_put(lapbeth->ethdev);
518		unregister_netdevice(lapbeth->axdev);
519	}
520	rtnl_unlock();
521}
522module_exit(lapbeth_cleanup_driver);
523
524MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
525MODULE_DESCRIPTION("The unofficial LAPB over Ethernet driver");
526MODULE_LICENSE("GPL");
527