1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/errno.h>
24#include <linux/types.h>
25#include <linux/socket.h>
26#include <linux/in.h>
27#include <linux/kernel.h>
28#include <linux/string.h>
29#include <linux/net.h>
30#include <linux/inet.h>
31#include <linux/netdevice.h>
32#include <linux/if_arp.h>
33#include <linux/skbuff.h>
34#include <net/sock.h>
35#include <asm/system.h>
36#include <asm/uaccess.h>
37#include <linux/mm.h>
38#include <linux/interrupt.h>
39#include <linux/notifier.h>
40#include <linux/stat.h>
41#include <linux/netfilter.h>
42#include <linux/module.h>
43#include <linux/lapb.h>
44#include <linux/init.h>
45
46#include <net/x25device.h>
47
48static char bcast_addr[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
49
50
51
52#define MAXLAPBDEV 100
53
54struct lapbethdev {
55 struct list_head node;
56 struct net_device *ethdev;
57 struct net_device *axdev;
58 struct net_device_stats stats;
59};
60
61static struct list_head lapbeth_devices = LIST_HEAD_INIT(lapbeth_devices);
62
63
64
65
66
67
68static struct lapbethdev *lapbeth_get_x25_dev(struct net_device *dev)
69{
70 struct lapbethdev *lapbeth;
71
72 list_for_each_entry_rcu(lapbeth, &lapbeth_devices, node) {
73 if (lapbeth->ethdev == dev)
74 return lapbeth;
75 }
76 return NULL;
77}
78
79static __inline__ int dev_is_ethdev(struct net_device *dev)
80{
81 return dev->type == ARPHRD_ETHER && strncmp(dev->name, "dummy", 5);
82}
83
84
85
86
87
88
89static int lapbeth_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *ptype, struct net_device *orig_dev)
90{
91 int len, err;
92 struct lapbethdev *lapbeth;
93
94 if (dev->nd_net != &init_net)
95 goto drop;
96
97 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
98 return NET_RX_DROP;
99
100 if (!pskb_may_pull(skb, 2))
101 goto drop;
102
103 rcu_read_lock();
104 lapbeth = lapbeth_get_x25_dev(dev);
105 if (!lapbeth)
106 goto drop_unlock;
107 if (!netif_running(lapbeth->axdev))
108 goto drop_unlock;
109
110 lapbeth->stats.rx_packets++;
111
112 len = skb->data[0] + skb->data[1] * 256;
113 lapbeth->stats.rx_bytes += len;
114
115 skb_pull(skb, 2);
116 skb_trim(skb, len);
117
118 if ((err = lapb_data_received(lapbeth->axdev, skb)) != LAPB_OK) {
119 printk(KERN_DEBUG "lapbether: lapb_data_received err - %d\n", err);
120 goto drop_unlock;
121 }
122out:
123 rcu_read_unlock();
124 return 0;
125drop_unlock:
126 kfree_skb(skb);
127 goto out;
128drop:
129 kfree_skb(skb);
130 return 0;
131}
132
133static int lapbeth_data_indication(struct net_device *dev, struct sk_buff *skb)
134{
135 unsigned char *ptr;
136
137 skb_push(skb, 1);
138
139 if (skb_cow(skb, 1))
140 return NET_RX_DROP;
141
142 ptr = skb->data;
143 *ptr = 0x00;
144
145 skb->protocol = x25_type_trans(skb, dev);
146 skb->dev->last_rx = jiffies;
147 return netif_rx(skb);
148}
149
150
151
152
153static int lapbeth_xmit(struct sk_buff *skb, struct net_device *dev)
154{
155 int err = -ENODEV;
156
157
158
159
160
161 if (!netif_running(dev)) {
162 goto drop;
163 }
164
165 switch (skb->data[0]) {
166 case 0x00:
167 err = 0;
168 break;
169 case 0x01:
170 if ((err = lapb_connect_request(dev)) != LAPB_OK)
171 printk(KERN_ERR "lapbeth: lapb_connect_request "
172 "error: %d\n", err);
173 goto drop_ok;
174 case 0x02:
175 if ((err = lapb_disconnect_request(dev)) != LAPB_OK)
176 printk(KERN_ERR "lapbeth: lapb_disconnect_request "
177 "err: %d\n", err);
178
179 default:
180 goto drop_ok;
181 }
182
183 skb_pull(skb, 1);
184
185 if ((err = lapb_data_request(dev, skb)) != LAPB_OK) {
186 printk(KERN_ERR "lapbeth: lapb_data_request error - %d\n", err);
187 err = -ENOMEM;
188 goto drop;
189 }
190 err = 0;
191out:
192 return err;
193drop_ok:
194 err = 0;
195drop:
196 kfree_skb(skb);
197 goto out;
198}
199
200static void lapbeth_data_transmit(struct net_device *ndev, struct sk_buff *skb)
201{
202 struct lapbethdev *lapbeth = netdev_priv(ndev);
203 unsigned char *ptr;
204 struct net_device *dev;
205 int size = skb->len;
206
207 skb->protocol = htons(ETH_P_X25);
208
209 ptr = skb_push(skb, 2);
210
211 *ptr++ = size % 256;
212 *ptr++ = size / 256;
213
214 lapbeth->stats.tx_packets++;
215 lapbeth->stats.tx_bytes += size;
216
217 skb->dev = dev = lapbeth->ethdev;
218
219 dev_hard_header(skb, dev, ETH_P_DEC, bcast_addr, NULL, 0);
220
221 dev_queue_xmit(skb);
222}
223
224static void lapbeth_connected(struct net_device *dev, int reason)
225{
226 unsigned char *ptr;
227 struct sk_buff *skb = dev_alloc_skb(1);
228
229 if (!skb) {
230 printk(KERN_ERR "lapbeth: out of memory\n");
231 return;
232 }
233
234 ptr = skb_put(skb, 1);
235 *ptr = 0x01;
236
237 skb->protocol = x25_type_trans(skb, dev);
238 skb->dev->last_rx = jiffies;
239 netif_rx(skb);
240}
241
242static void lapbeth_disconnected(struct net_device *dev, int reason)
243{
244 unsigned char *ptr;
245 struct sk_buff *skb = dev_alloc_skb(1);
246
247 if (!skb) {
248 printk(KERN_ERR "lapbeth: out of memory\n");
249 return;
250 }
251
252 ptr = skb_put(skb, 1);
253 *ptr = 0x02;
254
255 skb->protocol = x25_type_trans(skb, dev);
256 skb->dev->last_rx = jiffies;
257 netif_rx(skb);
258}
259
260
261
262
263static struct net_device_stats *lapbeth_get_stats(struct net_device *dev)
264{
265 struct lapbethdev *lapbeth = netdev_priv(dev);
266 return &lapbeth->stats;
267}
268
269
270
271
272static int lapbeth_set_mac_address(struct net_device *dev, void *addr)
273{
274 struct sockaddr *sa = addr;
275 memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
276 return 0;
277}
278
279
280static struct lapb_register_struct lapbeth_callbacks = {
281 .connect_confirmation = lapbeth_connected,
282 .connect_indication = lapbeth_connected,
283 .disconnect_confirmation = lapbeth_disconnected,
284 .disconnect_indication = lapbeth_disconnected,
285 .data_indication = lapbeth_data_indication,
286 .data_transmit = lapbeth_data_transmit,
287
288};
289
290
291
292
293static int lapbeth_open(struct net_device *dev)
294{
295 int err;
296
297 if ((err = lapb_register(dev, &lapbeth_callbacks)) != LAPB_OK) {
298 printk(KERN_ERR "lapbeth: lapb_register error - %d\n", err);
299 return -ENODEV;
300 }
301
302 netif_start_queue(dev);
303 return 0;
304}
305
306static int lapbeth_close(struct net_device *dev)
307{
308 int err;
309
310 netif_stop_queue(dev);
311
312 if ((err = lapb_unregister(dev)) != LAPB_OK)
313 printk(KERN_ERR "lapbeth: lapb_unregister error - %d\n", err);
314
315 return 0;
316}
317
318
319
320static void lapbeth_setup(struct net_device *dev)
321{
322 dev->hard_start_xmit = lapbeth_xmit;
323 dev->open = lapbeth_open;
324 dev->stop = lapbeth_close;
325 dev->destructor = free_netdev;
326 dev->set_mac_address = lapbeth_set_mac_address;
327 dev->get_stats = lapbeth_get_stats;
328 dev->type = ARPHRD_X25;
329 dev->hard_header_len = 3;
330 dev->mtu = 1000;
331 dev->addr_len = 0;
332}
333
334
335
336
337static int lapbeth_new_device(struct net_device *dev)
338{
339 struct net_device *ndev;
340 struct lapbethdev *lapbeth;
341 int rc = -ENOMEM;
342
343 ASSERT_RTNL();
344
345 ndev = alloc_netdev(sizeof(*lapbeth), "lapb%d",
346 lapbeth_setup);
347 if (!ndev)
348 goto out;
349
350 lapbeth = netdev_priv(ndev);
351 lapbeth->axdev = ndev;
352
353 dev_hold(dev);
354 lapbeth->ethdev = dev;
355
356 rc = dev_alloc_name(ndev, ndev->name);
357 if (rc < 0)
358 goto fail;
359
360 rc = -EIO;
361 if (register_netdevice(ndev))
362 goto fail;
363
364 list_add_rcu(&lapbeth->node, &lapbeth_devices);
365 rc = 0;
366out:
367 return rc;
368fail:
369 dev_put(dev);
370 free_netdev(ndev);
371 kfree(lapbeth);
372 goto out;
373}
374
375
376
377
378static void lapbeth_free_device(struct lapbethdev *lapbeth)
379{
380 dev_put(lapbeth->ethdev);
381 list_del_rcu(&lapbeth->node);
382 unregister_netdevice(lapbeth->axdev);
383}
384
385
386
387
388
389
390static int lapbeth_device_event(struct notifier_block *this,
391 unsigned long event, void *ptr)
392{
393 struct lapbethdev *lapbeth;
394 struct net_device *dev = ptr;
395
396 if (dev->nd_net != &init_net)
397 return NOTIFY_DONE;
398
399 if (!dev_is_ethdev(dev))
400 return NOTIFY_DONE;
401
402 switch (event) {
403 case NETDEV_UP:
404
405 if (lapbeth_get_x25_dev(dev) == NULL)
406 lapbeth_new_device(dev);
407 break;
408 case NETDEV_DOWN:
409
410 lapbeth = lapbeth_get_x25_dev(dev);
411 if (lapbeth)
412 dev_close(lapbeth->axdev);
413 break;
414 case NETDEV_UNREGISTER:
415
416 lapbeth = lapbeth_get_x25_dev(dev);
417 if (lapbeth)
418 lapbeth_free_device(lapbeth);
419 break;
420 }
421
422 return NOTIFY_DONE;
423}
424
425
426
427static struct packet_type lapbeth_packet_type = {
428 .type = __constant_htons(ETH_P_DEC),
429 .func = lapbeth_rcv,
430};
431
432static struct notifier_block lapbeth_dev_notifier = {
433 .notifier_call = lapbeth_device_event,
434};
435
436static char banner[] __initdata = KERN_INFO "LAPB Ethernet driver version 0.02\n";
437
438static int __init lapbeth_init_driver(void)
439{
440 dev_add_pack(&lapbeth_packet_type);
441
442 register_netdevice_notifier(&lapbeth_dev_notifier);
443
444 printk(banner);
445
446 return 0;
447}
448module_init(lapbeth_init_driver);
449
450static void __exit lapbeth_cleanup_driver(void)
451{
452 struct lapbethdev *lapbeth;
453 struct list_head *entry, *tmp;
454
455 dev_remove_pack(&lapbeth_packet_type);
456 unregister_netdevice_notifier(&lapbeth_dev_notifier);
457
458 rtnl_lock();
459 list_for_each_safe(entry, tmp, &lapbeth_devices) {
460 lapbeth = list_entry(entry, struct lapbethdev, node);
461
462 unregister_netdevice(lapbeth->axdev);
463 }
464 rtnl_unlock();
465}
466module_exit(lapbeth_cleanup_driver);
467
468MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
469MODULE_DESCRIPTION("The unofficial LAPB over Ethernet driver");
470MODULE_LICENSE("GPL");
471
