projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[NET]: Make packet reception network namespace safe
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / ax25 / af_ax25.c
CommitLineData
1da177e4
LT		 1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
8 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
10 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
11 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
12 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
13 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
14 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
15 */
4fc268d2 16#include <linux/capability.h>
1da177e4
LT		 17#include <linux/module.h>
18#include <linux/errno.h>
19#include <linux/types.h>
20#include <linux/socket.h>
21#include <linux/in.h>
22#include <linux/kernel.h>
23#include <linux/sched.h>
24#include <linux/timer.h>
25#include <linux/string.h>
1da177e4
LT		 26#include <linux/sockios.h>
27#include <linux/net.h>
28#include <net/ax25.h>
29#include <linux/inet.h>
30#include <linux/netdevice.h>
31#include <linux/if_arp.h>
32#include <linux/skbuff.h>
33#include <net/sock.h>
34#include <asm/uaccess.h>
35#include <asm/system.h>
36#include <linux/fcntl.h>
37#include <linux/termios.h> /* For TIOCINQ/OUTQ */
38#include <linux/mm.h>
39#include <linux/interrupt.h>
40#include <linux/notifier.h>
41#include <linux/proc_fs.h>
42#include <linux/stat.h>
43#include <linux/netfilter.h>
44#include <linux/sysctl.h>
45#include <linux/init.h>
46#include <linux/spinlock.h>
457c4cbc 47#include <net/net_namespace.h>
c752f073 48#include <net/tcp_states.h>
1da177e4
LT		 49#include <net/ip.h>
50#include <net/arp.h>
51
52
53
54HLIST_HEAD(ax25_list);
55DEFINE_SPINLOCK(ax25_list_lock);
56
90ddc4f0 57static const struct proto_ops ax25_proto_ops;
1da177e4
LT		 58
59static void ax25_free_sock(struct sock *sk)
60{
61 ax25_cb_put(ax25_sk(sk));
62}
63
64/*
65 * Socket removal during an interrupt is now safe.
66 */
67static void ax25_cb_del(ax25_cb *ax25)
68{
69 if (!hlist_unhashed(&ax25->ax25_node)) {
70 spin_lock_bh(&ax25_list_lock);
71 hlist_del_init(&ax25->ax25_node);
72 spin_unlock_bh(&ax25_list_lock);
73 ax25_cb_put(ax25);
74 }
75}
76
77/*
78 * Kill all bound sockets on a dropped device.
79 */
80static void ax25_kill_by_device(struct net_device *dev)
81{
82 ax25_dev *ax25_dev;
83 ax25_cb *s;
84 struct hlist_node *node;
85
86 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
87 return;
88
89 spin_lock_bh(&ax25_list_lock);
90 ax25_for_each(s, node, &ax25_list) {
91 if (s->ax25_dev == ax25_dev) {
92 s->ax25_dev = NULL;
93 ax25_disconnect(s, ENETUNREACH);
94 }
95 }
96 spin_unlock_bh(&ax25_list_lock);
97}
98
99/*
100 * Handle device status changes.
101 */
102static int ax25_device_event(struct notifier_block *this, unsigned long event,
103 void *ptr)
104{
105 struct net_device *dev = (struct net_device *)ptr;
106
107 /* Reject non AX.25 devices */
108 if (dev->type != ARPHRD_AX25)
109 return NOTIFY_DONE;
110
111 switch (event) {
112 case NETDEV_UP:
113 ax25_dev_device_up(dev);
114 break;
115 case NETDEV_DOWN:
116 ax25_kill_by_device(dev);
117 ax25_rt_device_down(dev);
118 ax25_dev_device_down(dev);
119 break;
120 default:
121 break;
122 }
123
124 return NOTIFY_DONE;
125}
126
127/*
128 * Add a socket to the bound sockets list.
129 */
130void ax25_cb_add(ax25_cb *ax25)
131{
132 spin_lock_bh(&ax25_list_lock);
133 ax25_cb_hold(ax25);
134 hlist_add_head(&ax25->ax25_node, &ax25_list);
135 spin_unlock_bh(&ax25_list_lock);
136}
137
138/*
139 * Find a socket that wants to accept the SABM we have just
140 * received.
141 */
142struct sock *ax25_find_listener(ax25_address *addr, int digi,
143 struct net_device *dev, int type)
144{
145 ax25_cb *s;
146 struct hlist_node *node;
147
c19c4b9c 148 spin_lock(&ax25_list_lock);
1da177e4
LT		 149 ax25_for_each(s, node, &ax25_list) {
150 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
151 continue;
152 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
153 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
154 /* If device is null we match any device */
155 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
156 sock_hold(s->sk);
c19c4b9c 157 spin_unlock(&ax25_list_lock);
1da177e4
LT		 158 return s->sk;
159 }
160 }
161 }
c19c4b9c 162 spin_unlock(&ax25_list_lock);
1da177e4
LT		 163
164 return NULL;
165}
166
167/*
168 * Find an AX.25 socket given both ends.
169 */
170struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
171 int type)
172{
173 struct sock *sk = NULL;
174 ax25_cb *s;
175 struct hlist_node *node;
176
c19c4b9c 177 spin_lock(&ax25_list_lock);
1da177e4
LT		 178 ax25_for_each(s, node, &ax25_list) {
179 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
180 !ax25cmp(&s->dest_addr, dest_addr) &&
181 s->sk->sk_type == type) {
182 sk = s->sk;
183 sock_hold(sk);
184 break;
185 }
186 }
187
c19c4b9c 188 spin_unlock(&ax25_list_lock);
1da177e4
LT		 189
190 return sk;
191}
192
193/*
194 * Find an AX.25 control block given both ends. It will only pick up
195 * floating AX.25 control blocks or non Raw socket bound control blocks.
196 */
197ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
198 ax25_digi *digi, struct net_device *dev)
199{
200 ax25_cb *s;
201 struct hlist_node *node;
202
203 spin_lock_bh(&ax25_list_lock);
204 ax25_for_each(s, node, &ax25_list) {
205 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
206 continue;
207 if (s->ax25_dev == NULL)
208 continue;
209 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
210 if (digi != NULL && digi->ndigi != 0) {
211 if (s->digipeat == NULL)
212 continue;
213 if (ax25digicmp(s->digipeat, digi) != 0)
214 continue;
215 } else {
216 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
217 continue;
218 }
219 ax25_cb_hold(s);
220 spin_unlock_bh(&ax25_list_lock);
221
222 return s;
223 }
224 }
225 spin_unlock_bh(&ax25_list_lock);
226
227 return NULL;
228}
229
70868eac
RB		 230EXPORT_SYMBOL(ax25_find_cb);
231
1da177e4
LT		 232void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
233{
234 ax25_cb *s;
235 struct sk_buff *copy;
236 struct hlist_node *node;
237
c19c4b9c 238 spin_lock(&ax25_list_lock);
1da177e4
LT		 239 ax25_for_each(s, node, &ax25_list) {
240 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
241 s->sk->sk_type == SOCK_RAW &&
242 s->sk->sk_protocol == proto &&
243 s->ax25_dev->dev == skb->dev &&
244 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
245 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
246 continue;
247 if (sock_queue_rcv_skb(s->sk, copy) != 0)
248 kfree_skb(copy);
249 }
250 }
c19c4b9c 251 spin_unlock(&ax25_list_lock);
1da177e4
LT		 252}
253
254/*
255 * Deferred destroy.
256 */
257void ax25_destroy_socket(ax25_cb *);
258
259/*
260 * Handler for deferred kills.
261 */
262static void ax25_destroy_timer(unsigned long data)
263{
264 ax25_cb *ax25=(ax25_cb *)data;
265 struct sock *sk;
528930b9 266
1da177e4 267 sk=ax25->sk;
528930b9 268
1da177e4
LT		 269 bh_lock_sock(sk);
270 sock_hold(sk);
271 ax25_destroy_socket(ax25);
272 bh_unlock_sock(sk);
273 sock_put(sk);
274}
275
276/*
277 * This is called from user mode and the timers. Thus it protects itself
278 * against interrupt users but doesn't worry about being called during
279 * work. Once it is removed from the queue no interrupt or bottom half
280 * will touch it and we are (fairly 8-) ) safe.
281 */
282void ax25_destroy_socket(ax25_cb *ax25)
283{
284 struct sk_buff *skb;
285
286 ax25_cb_del(ax25);
287
288 ax25_stop_heartbeat(ax25);
289 ax25_stop_t1timer(ax25);
290 ax25_stop_t2timer(ax25);
291 ax25_stop_t3timer(ax25);
292 ax25_stop_idletimer(ax25);
293
294 ax25_clear_queues(ax25); /* Flush the queues */
295
296 if (ax25->sk != NULL) {
297 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
298 if (skb->sk != ax25->sk) {
299 /* A pending connection */
300 ax25_cb *sax25 = ax25_sk(skb->sk);
301
302 /* Queue the unaccepted socket for death */
303 sock_orphan(skb->sk);
304
305 ax25_start_heartbeat(sax25);
306 sax25->state = AX25_STATE_0;
307 }
308
309 kfree_skb(skb);
310 }
311 skb_queue_purge(&ax25->sk->sk_write_queue);
312 }
313
314 if (ax25->sk != NULL) {
315 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
316 atomic_read(&ax25->sk->sk_rmem_alloc)) {
317 /* Defer: outstanding buffers */
318 init_timer(&ax25->dtimer);
319 ax25->dtimer.expires = jiffies + 2 * HZ;
320 ax25->dtimer.function = ax25_destroy_timer;
321 ax25->dtimer.data = (unsigned long)ax25;
322 add_timer(&ax25->dtimer);
323 } else {
324 struct sock *sk=ax25->sk;
325 ax25->sk=NULL;
326 sock_put(sk);
327 }
328 } else {
329 ax25_cb_put(ax25);
330 }
331}
332
333/*
334 * dl1bke 960311: set parameters for existing AX.25 connections,
335 * includes a KILL command to abort any connection.
336 * VERY useful for debugging ;-)
337 */
338static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
339{
340 struct ax25_ctl_struct ax25_ctl;
341 ax25_digi digi;
342 ax25_dev *ax25_dev;
343 ax25_cb *ax25;
344 unsigned int k;
345
346 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
347 return -EFAULT;
348
349 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
350 return -ENODEV;
351
352 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
353 return -EINVAL;
354
355 digi.ndigi = ax25_ctl.digi_count;
356 for (k = 0; k < digi.ndigi; k++)
357 digi.calls[k] = ax25_ctl.digi_addr[k];
358
359 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
360 return -ENOTCONN;
361
362 switch (ax25_ctl.cmd) {
363 case AX25_KILL:
364 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
365#ifdef CONFIG_AX25_DAMA_SLAVE
366 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
367 ax25_dama_off(ax25);
368#endif
369 ax25_disconnect(ax25, ENETRESET);
370 break;
371
528930b9
YH		 372 case AX25_WINDOW:
373 if (ax25->modulus == AX25_MODULUS) {
374 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
375 return -EINVAL;
376 } else {
377 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
378 return -EINVAL;
379 }
380 ax25->window = ax25_ctl.arg;
381 break;
382
383 case AX25_T1:
1da177e4 384 if (ax25_ctl.arg < 1)
1da177e4 385 return -EINVAL;
528930b9
YH		 386 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
387 ax25->t1 = ax25_ctl.arg * HZ;
388 break;
389
390 case AX25_T2:
391 if (ax25_ctl.arg < 1)
392 return -EINVAL;
393 ax25->t2 = ax25_ctl.arg * HZ;
394 break;
395
396 case AX25_N2:
397 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
398 return -EINVAL;
399 ax25->n2count = 0;
400 ax25->n2 = ax25_ctl.arg;
401 break;
402
403 case AX25_T3:
404 if (ax25_ctl.arg < 0)
405 return -EINVAL;
406 ax25->t3 = ax25_ctl.arg * HZ;
407 break;
408
409 case AX25_IDLE:
410 if (ax25_ctl.arg < 0)
411 return -EINVAL;
412 ax25->idle = ax25_ctl.arg * 60 * HZ;
413 break;
414
415 case AX25_PACLEN:
416 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
417 return -EINVAL;
418 ax25->paclen = ax25_ctl.arg;
419 break;
420
421 default:
422 return -EINVAL;
1da177e4
LT		 423 }
424
425 return 0;
426}
427
e1fdb5b3
RB		 428static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
429{
430 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
431 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
432 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
433 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
434 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
435 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
436 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
437 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
438
439 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
440 ax25->modulus = AX25_EMODULUS;
441 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
442 } else {
443 ax25->modulus = AX25_MODULUS;
444 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
445 }
446}
447
1da177e4
LT		 448/*
449 * Fill in a created AX.25 created control block with the default
450 * values for a particular device.
451 */
452void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
453{
454 ax25->ax25_dev = ax25_dev;
455
456 if (ax25->ax25_dev != NULL) {
e1fdb5b3
RB		 457 ax25_fillin_cb_from_dev(ax25, ax25_dev);
458 return;
459 }
460
461 /*
462 * No device, use kernel / AX.25 spec default values
463 */
464 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
465 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
466 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
467 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
468 ax25->n2 = AX25_DEF_N2;
469 ax25->paclen = AX25_DEF_PACLEN;
470 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
471 ax25->backoff = AX25_DEF_BACKOFF;
472
473 if (AX25_DEF_AXDEFMODE) {
474 ax25->modulus = AX25_EMODULUS;
475 ax25->window = AX25_DEF_EWINDOW;
1da177e4 476 } else {
e1fdb5b3
RB		 477 ax25->modulus = AX25_MODULUS;
478 ax25->window = AX25_DEF_WINDOW;
1da177e4
LT		 479 }
480}
481
482/*
483 * Create an empty AX.25 control block.
484 */
485ax25_cb *ax25_create_cb(void)
486{
487 ax25_cb *ax25;
488
1b30dd35 489 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
1da177e4
LT		 490 return NULL;
491
1da177e4
LT		 492 atomic_set(&ax25->refcount, 1);
493
494 skb_queue_head_init(&ax25->write_queue);
495 skb_queue_head_init(&ax25->frag_queue);
496 skb_queue_head_init(&ax25->ack_queue);
497 skb_queue_head_init(&ax25->reseq_queue);
498
499 init_timer(&ax25->timer);
500 init_timer(&ax25->t1timer);
501 init_timer(&ax25->t2timer);
502 init_timer(&ax25->t3timer);
503 init_timer(&ax25->idletimer);
504
505 ax25_fillin_cb(ax25, NULL);
506
507 ax25->state = AX25_STATE_0;
508
509 return ax25;
510}
511
512/*
513 * Handling for system calls applied via the various interfaces to an
514 * AX25 socket object
515 */
516
517static int ax25_setsockopt(struct socket *sock, int level, int optname,
518 char __user *optval, int optlen)
519{
520 struct sock *sk = sock->sk;
521 ax25_cb *ax25;
522 struct net_device *dev;
523 char devname[IFNAMSIZ];
524 int opt, res = 0;
525
526 if (level != SOL_AX25)
527 return -ENOPROTOOPT;
528
529 if (optlen < sizeof(int))
530 return -EINVAL;
531
532 if (get_user(opt, (int __user *)optval))
533 return -EFAULT;
534
535 lock_sock(sk);
536 ax25 = ax25_sk(sk);
537
538 switch (optname) {
539 case AX25_WINDOW:
540 if (ax25->modulus == AX25_MODULUS) {
541 if (opt < 1 || opt > 7) {
542 res = -EINVAL;
543 break;
544 }
545 } else {
546 if (opt < 1 || opt > 63) {
547 res = -EINVAL;
548 break;
549 }
550 }
551 ax25->window = opt;
552 break;
553
554 case AX25_T1:
555 if (opt < 1) {
556 res = -EINVAL;
557 break;
558 }
559 ax25->rtt = (opt * HZ) / 2;
560 ax25->t1 = opt * HZ;
561 break;
562
563 case AX25_T2:
564 if (opt < 1) {
565 res = -EINVAL;
566 break;
567 }
568 ax25->t2 = opt * HZ;
569 break;
570
571 case AX25_N2:
572 if (opt < 1 || opt > 31) {
573 res = -EINVAL;
574 break;
575 }
576 ax25->n2 = opt;
577 break;
578
579 case AX25_T3:
580 if (opt < 1) {
581 res = -EINVAL;
582 break;
583 }
584 ax25->t3 = opt * HZ;
585 break;
586
587 case AX25_IDLE:
588 if (opt < 0) {
589 res = -EINVAL;
590 break;
591 }
592 ax25->idle = opt * 60 * HZ;
593 break;
594
595 case AX25_BACKOFF:
596 if (opt < 0 || opt > 2) {
597 res = -EINVAL;
598 break;
599 }
600 ax25->backoff = opt;
601 break;
602
603 case AX25_EXTSEQ:
604 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
605 break;
606
607 case AX25_PIDINCL:
608 ax25->pidincl = opt ? 1 : 0;
609 break;
610
611 case AX25_IAMDIGI:
612 ax25->iamdigi = opt ? 1 : 0;
613 break;
614
615 case AX25_PACLEN:
616 if (opt < 16 || opt > 65535) {
617 res = -EINVAL;
618 break;
619 }
620 ax25->paclen = opt;
621 break;
622
623 case SO_BINDTODEVICE:
624 if (optlen > IFNAMSIZ)
625 optlen=IFNAMSIZ;
626 if (copy_from_user(devname, optval, optlen)) {
627 res = -EFAULT;
628 break;
629 }
630
631 dev = dev_get_by_name(devname);
632 if (dev == NULL) {
633 res = -ENODEV;
634 break;
635 }
636
637 if (sk->sk_type == SOCK_SEQPACKET &&
638 (sock->state != SS_UNCONNECTED ||
639 sk->sk_state == TCP_LISTEN)) {
640 res = -EADDRNOTAVAIL;
641 dev_put(dev);
642 break;
643 }
644
645 ax25->ax25_dev = ax25_dev_ax25dev(dev);
646 ax25_fillin_cb(ax25, ax25->ax25_dev);
647 break;
648
649 default:
650 res = -ENOPROTOOPT;
651 }
652 release_sock(sk);
653
654 return res;
655}
656
657static int ax25_getsockopt(struct socket *sock, int level, int optname,
658 char __user *optval, int __user *optlen)
659{
660 struct sock *sk = sock->sk;
661 ax25_cb *ax25;
662 struct ax25_dev *ax25_dev;
663 char devname[IFNAMSIZ];
664 void *valptr;
665 int val = 0;
666 int maxlen, length;
667
668 if (level != SOL_AX25)
669 return -ENOPROTOOPT;
670
671 if (get_user(maxlen, optlen))
672 return -EFAULT;
673
674 if (maxlen < 1)
675 return -EFAULT;
676
677 valptr = (void *) &val;
678 length = min_t(unsigned int, maxlen, sizeof(int));
679
680 lock_sock(sk);
681 ax25 = ax25_sk(sk);
682
683 switch (optname) {
684 case AX25_WINDOW:
685 val = ax25->window;
686 break;
687
688 case AX25_T1:
689 val = ax25->t1 / HZ;
690 break;
691
692 case AX25_T2:
693 val = ax25->t2 / HZ;
694 break;
695
696 case AX25_N2:
697 val = ax25->n2;
698 break;
699
700 case AX25_T3:
701 val = ax25->t3 / HZ;
702 break;
703
704 case AX25_IDLE:
705 val = ax25->idle / (60 * HZ);
706 break;
707
708 case AX25_BACKOFF:
709 val = ax25->backoff;
710 break;
711
712 case AX25_EXTSEQ:
713 val = (ax25->modulus == AX25_EMODULUS);
714 break;
715
716 case AX25_PIDINCL:
717 val = ax25->pidincl;
718 break;
719
720 case AX25_IAMDIGI:
721 val = ax25->iamdigi;
722 break;
723
724 case AX25_PACLEN:
725 val = ax25->paclen;
726 break;
727
728 case SO_BINDTODEVICE:
729 ax25_dev = ax25->ax25_dev;
730
731 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
732 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
733 length = strlen(devname) + 1;
734 } else {
735 *devname = '\0';
736 length = 1;
737 }
738
739 valptr = (void *) devname;
740 break;
741
742 default:
743 release_sock(sk);
744 return -ENOPROTOOPT;
745 }
746 release_sock(sk);
747
748 if (put_user(length, optlen))
749 return -EFAULT;
750
751 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
752}
753
754static int ax25_listen(struct socket *sock, int backlog)
755{
756 struct sock *sk = sock->sk;
757 int res = 0;
758
759 lock_sock(sk);
760 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
761 sk->sk_max_ack_backlog = backlog;
762 sk->sk_state = TCP_LISTEN;
763 goto out;
764 }
765 res = -EOPNOTSUPP;
766
767out:
768 release_sock(sk);
769
770 return res;
771}
772
773/*
774 * XXX: when creating ax25_sock we should update the .obj_size setting
775 * below.
776 */
777static struct proto ax25_proto = {
778 .name = "AX25",
779 .owner = THIS_MODULE,
780 .obj_size = sizeof(struct sock),
781};
782
1b8d7ae4 783static int ax25_create(struct net *net, struct socket *sock, int protocol)
1da177e4
LT		 784{
785 struct sock *sk;
786 ax25_cb *ax25;
787
1b8d7ae4
EB		 788 if (net != &init_net)
789 return -EAFNOSUPPORT;
790
1da177e4
LT		 791 switch (sock->type) {
792 case SOCK_DGRAM:
793 if (protocol == 0 || protocol == PF_AX25)
794 protocol = AX25_P_TEXT;
795 break;
796
797 case SOCK_SEQPACKET:
798 switch (protocol) {
799 case 0:
800 case PF_AX25: /* For CLX */
801 protocol = AX25_P_TEXT;
802 break;
803 case AX25_P_SEGMENT:
804#ifdef CONFIG_INET
805 case AX25_P_ARP:
806 case AX25_P_IP:
807#endif
808#ifdef CONFIG_NETROM
809 case AX25_P_NETROM:
810#endif
811#ifdef CONFIG_ROSE
812 case AX25_P_ROSE:
813#endif
814 return -ESOCKTNOSUPPORT;
815#ifdef CONFIG_NETROM_MODULE
816 case AX25_P_NETROM:
817 if (ax25_protocol_is_registered(AX25_P_NETROM))
818 return -ESOCKTNOSUPPORT;
819#endif
820#ifdef CONFIG_ROSE_MODULE
821 case AX25_P_ROSE:
822 if (ax25_protocol_is_registered(AX25_P_ROSE))
823 return -ESOCKTNOSUPPORT;
824#endif
825 default:
826 break;
827 }
828 break;
829
830 case SOCK_RAW:
831 break;
832 default:
833 return -ESOCKTNOSUPPORT;
834 }
835
1b8d7ae4 836 if ((sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, 1)) == NULL)
1da177e4
LT		 837 return -ENOMEM;
838
839 ax25 = sk->sk_protinfo = ax25_create_cb();
840 if (!ax25) {
841 sk_free(sk);
842 return -ENOMEM;
843 }
844
845 sock_init_data(sock, sk);
846
847 sk->sk_destruct = ax25_free_sock;
848 sock->ops = &ax25_proto_ops;
849 sk->sk_protocol = protocol;
850
851 ax25->sk = sk;
852
853 return 0;
854}
855
856struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
857{
858 struct sock *sk;
859 ax25_cb *ax25, *oax25;
860
1b8d7ae4 861 if ((sk = sk_alloc(osk->sk_net, PF_AX25, GFP_ATOMIC, osk->sk_prot, 1)) == NULL)
1da177e4
LT		 862 return NULL;
863
864 if ((ax25 = ax25_create_cb()) == NULL) {
865 sk_free(sk);
866 return NULL;
867 }
868
869 switch (osk->sk_type) {
870 case SOCK_DGRAM:
871 break;
872 case SOCK_SEQPACKET:
873 break;
874 default:
875 sk_free(sk);
876 ax25_cb_put(ax25);
877 return NULL;
878 }
879
880 sock_init_data(NULL, sk);
881
882 sk->sk_destruct = ax25_free_sock;
883 sk->sk_type = osk->sk_type;
884 sk->sk_socket = osk->sk_socket;
885 sk->sk_priority = osk->sk_priority;
886 sk->sk_protocol = osk->sk_protocol;
887 sk->sk_rcvbuf = osk->sk_rcvbuf;
888 sk->sk_sndbuf = osk->sk_sndbuf;
889 sk->sk_state = TCP_ESTABLISHED;
890 sk->sk_sleep = osk->sk_sleep;
53b924b3 891 sock_copy_flags(sk, osk);
1da177e4
LT		 892
893 oax25 = ax25_sk(osk);
894
895 ax25->modulus = oax25->modulus;
896 ax25->backoff = oax25->backoff;
897 ax25->pidincl = oax25->pidincl;
898 ax25->iamdigi = oax25->iamdigi;
899 ax25->rtt = oax25->rtt;
900 ax25->t1 = oax25->t1;
901 ax25->t2 = oax25->t2;
902 ax25->t3 = oax25->t3;
903 ax25->n2 = oax25->n2;
904 ax25->idle = oax25->idle;
905 ax25->paclen = oax25->paclen;
906 ax25->window = oax25->window;
907
908 ax25->ax25_dev = ax25_dev;
909 ax25->source_addr = oax25->source_addr;
910
911 if (oax25->digipeat != NULL) {
0459d70a
ACM		 912 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
913 GFP_ATOMIC);
914 if (ax25->digipeat == NULL) {
1da177e4
LT		 915 sk_free(sk);
916 ax25_cb_put(ax25);
917 return NULL;
918 }
1da177e4
LT		 919 }
920
921 sk->sk_protinfo = ax25;
922 ax25->sk = sk;
923
924 return sk;
925}
926
927static int ax25_release(struct socket *sock)
928{
929 struct sock *sk = sock->sk;
930 ax25_cb *ax25;
931
932 if (sk == NULL)
933 return 0;
934
935 sock_hold(sk);
936 sock_orphan(sk);
937 lock_sock(sk);
938 ax25 = ax25_sk(sk);
939
940 if (sk->sk_type == SOCK_SEQPACKET) {
941 switch (ax25->state) {
942 case AX25_STATE_0:
943 release_sock(sk);
944 ax25_disconnect(ax25, 0);
945 lock_sock(sk);
946 ax25_destroy_socket(ax25);
947 break;
948
949 case AX25_STATE_1:
950 case AX25_STATE_2:
951 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
952 release_sock(sk);
953 ax25_disconnect(ax25, 0);
954 lock_sock(sk);
955 ax25_destroy_socket(ax25);
956 break;
957
958 case AX25_STATE_3:
959 case AX25_STATE_4:
960 ax25_clear_queues(ax25);
961 ax25->n2count = 0;
962
963 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
964 case AX25_PROTO_STD_SIMPLEX:
965 case AX25_PROTO_STD_DUPLEX:
966 ax25_send_control(ax25,
967 AX25_DISC,
968 AX25_POLLON,
969 AX25_COMMAND);
970 ax25_stop_t2timer(ax25);
971 ax25_stop_t3timer(ax25);
972 ax25_stop_idletimer(ax25);
973 break;
974#ifdef CONFIG_AX25_DAMA_SLAVE
975 case AX25_PROTO_DAMA_SLAVE:
976 ax25_stop_t3timer(ax25);
977 ax25_stop_idletimer(ax25);
978 break;
979#endif
980 }
981 ax25_calculate_t1(ax25);
982 ax25_start_t1timer(ax25);
983 ax25->state = AX25_STATE_2;
984 sk->sk_state = TCP_CLOSE;
985 sk->sk_shutdown |= SEND_SHUTDOWN;
986 sk->sk_state_change(sk);
987 sock_set_flag(sk, SOCK_DESTROY);
988 break;
989
990 default:
991 break;
992 }
993 } else {
994 sk->sk_state = TCP_CLOSE;
995 sk->sk_shutdown |= SEND_SHUTDOWN;
996 sk->sk_state_change(sk);
997 ax25_destroy_socket(ax25);
998 }
999
1000 sock->sk = NULL;
1001 release_sock(sk);
1002 sock_put(sk);
1003
1004 return 0;
1005}
1006
1007/*
1008 * We support a funny extension here so you can (as root) give any callsign
1009 * digipeated via a local address as source. This hack is obsolete now
1010 * that we've implemented support for SO_BINDTODEVICE. It is however small
1011 * and trivially backward compatible.
1012 */
1013static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1014{
1015 struct sock *sk = sock->sk;
1016 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1017 ax25_dev *ax25_dev = NULL;
01d7dd0e
RB		 1018 ax25_uid_assoc *user;
1019 ax25_address call;
1da177e4
LT		 1020 ax25_cb *ax25;
1021 int err = 0;
1022
1023 if (addr_len != sizeof(struct sockaddr_ax25) &&
1024 addr_len != sizeof(struct full_sockaddr_ax25)) {
1025 /* support for old structure may go away some time */
1026 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1027 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1028 return -EINVAL;
1029 }
1030
1031 printk(KERN_WARNING "ax25_bind(): %s uses old (6 digipeater) socket structure.\n",
1032 current->comm);
1033 }
1034
1035 if (addr->fsa_ax25.sax25_family != AF_AX25)
1036 return -EINVAL;
1037
01d7dd0e
RB		 1038 user = ax25_findbyuid(current->euid);
1039 if (user) {
1040 call = user->call;
1041 ax25_uid_put(user);
1042 } else {
1043 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1044 return -EACCES;
1045
1046 call = addr->fsa_ax25.sax25_call;
1da177e4
LT		 1047 }
1048
1049 lock_sock(sk);
1050
1051 ax25 = ax25_sk(sk);
1052 if (!sock_flag(sk, SOCK_ZAPPED)) {
1053 err = -EINVAL;
1054 goto out;
1055 }
1056
01d7dd0e 1057 ax25->source_addr = call;
1da177e4
LT		 1058
1059 /*
1060 * User already set interface with SO_BINDTODEVICE
1061 */
1062 if (ax25->ax25_dev != NULL)
1063 goto done;
1064
1065 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1066 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1067 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1068 err = -EADDRNOTAVAIL;
1069 goto out;
1070 }
1071 } else {
1072 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1073 err = -EADDRNOTAVAIL;
1074 goto out;
1075 }
1076 }
1077
1078 if (ax25_dev != NULL)
1079 ax25_fillin_cb(ax25, ax25_dev);
1080
1081done:
1082 ax25_cb_add(ax25);
1083 sock_reset_flag(sk, SOCK_ZAPPED);
1084
1085out:
1086 release_sock(sk);
1087
1088 return 0;
1089}
1090
1091/*
1092 * FIXME: nonblock behaviour looks like it may have a bug.
1093 */
c9266b99
RB		 1094static int __must_check ax25_connect(struct socket *sock,
1095 struct sockaddr *uaddr, int addr_len, int flags)
1da177e4
LT		 1096{
1097 struct sock *sk = sock->sk;
1098 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1099 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1100 ax25_digi *digi = NULL;
1101 int ct = 0, err = 0;
1102
1103 /*
1104 * some sanity checks. code further down depends on this
1105 */
1106
1107 if (addr_len == sizeof(struct sockaddr_ax25)) {
1108 /* support for this will go away in early 2.5.x */
1109 printk(KERN_WARNING "ax25_connect(): %s uses obsolete socket structure\n",
1110 current->comm);
1111 }
1112 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1113 /* support for old structure may go away some time */
1114 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1115 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1116 return -EINVAL;
1117 }
1118
1119 printk(KERN_WARNING "ax25_connect(): %s uses old (6 digipeater) socket structure.\n",
1120 current->comm);
1121 }
1122
1123 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1124 return -EINVAL;
1125
1126 lock_sock(sk);
1127
1128 /* deal with restarts */
1129 if (sock->state == SS_CONNECTING) {
1130 switch (sk->sk_state) {
1131 case TCP_SYN_SENT: /* still trying */
1132 err = -EINPROGRESS;
75606dc6 1133 goto out_release;
1da177e4
LT		 1134
1135 case TCP_ESTABLISHED: /* connection established */
1136 sock->state = SS_CONNECTED;
75606dc6 1137 goto out_release;
1da177e4
LT		 1138
1139 case TCP_CLOSE: /* connection refused */
1140 sock->state = SS_UNCONNECTED;
1141 err = -ECONNREFUSED;
75606dc6 1142 goto out_release;
1da177e4
LT		 1143 }
1144 }
1145
1146 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1147 err = -EISCONN; /* No reconnect on a seqpacket socket */
75606dc6 1148 goto out_release;
1da177e4
LT		 1149 }
1150
1151 sk->sk_state = TCP_CLOSE;
1152 sock->state = SS_UNCONNECTED;
1153
a51482bd
JJ		 1154 kfree(ax25->digipeat);
1155 ax25->digipeat = NULL;
1da177e4
LT		 1156
1157 /*
1158 * Handle digi-peaters to be used.
1159 */
1160 if (addr_len > sizeof(struct sockaddr_ax25) &&
1161 fsa->fsa_ax25.sax25_ndigis != 0) {
1162 /* Valid number of digipeaters ? */
1163 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1164 err = -EINVAL;
75606dc6 1165 goto out_release;
1da177e4
LT		 1166 }
1167
1168 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1169 err = -ENOBUFS;
75606dc6 1170 goto out_release;
1da177e4
LT		 1171 }
1172
1173 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1174 digi->lastrepeat = -1;
1175
1176 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1177 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1178 AX25_HBIT) && ax25->iamdigi) {
1179 digi->repeated[ct] = 1;
1180 digi->lastrepeat = ct;
1181 } else {
1182 digi->repeated[ct] = 0;
1183 }
1184 digi->calls[ct] = fsa->fsa_digipeater[ct];
1185 ct++;
1186 }
1187 }
1188
1189 /*
1190 * Must bind first - autobinding in this may or may not work. If
1191 * the socket is already bound, check to see if the device has
1192 * been filled in, error if it hasn't.
1193 */
1194 if (sock_flag(sk, SOCK_ZAPPED)) {
1195 /* check if we can remove this feature. It is broken. */
1196 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1197 current->comm);
1198 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1199 kfree(digi);
75606dc6 1200 goto out_release;
1da177e4
LT		 1201 }
1202
1203 ax25_fillin_cb(ax25, ax25->ax25_dev);
1204 ax25_cb_add(ax25);
1205 } else {
1206 if (ax25->ax25_dev == NULL) {
1207 kfree(digi);
1208 err = -EHOSTUNREACH;
75606dc6 1209 goto out_release;
1da177e4
LT		 1210 }
1211 }
1212
1213 if (sk->sk_type == SOCK_SEQPACKET &&
1214 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
528930b9 1215 ax25->ax25_dev->dev))) {
1da177e4
LT		 1216 kfree(digi);
1217 err = -EADDRINUSE; /* Already such a connection */
1218 ax25_cb_put(ax25t);
75606dc6 1219 goto out_release;
1da177e4
LT		 1220 }
1221
1222 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1223 ax25->digipeat = digi;
1224
1225 /* First the easy one */
1226 if (sk->sk_type != SOCK_SEQPACKET) {
1227 sock->state = SS_CONNECTED;
1228 sk->sk_state = TCP_ESTABLISHED;
75606dc6 1229 goto out_release;
1da177e4
LT		 1230 }
1231
1232 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1233 sock->state = SS_CONNECTING;
1234 sk->sk_state = TCP_SYN_SENT;
1235
1236 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1237 case AX25_PROTO_STD_SIMPLEX:
1238 case AX25_PROTO_STD_DUPLEX:
1239 ax25_std_establish_data_link(ax25);
1240 break;
1241
1242#ifdef CONFIG_AX25_DAMA_SLAVE
1243 case AX25_PROTO_DAMA_SLAVE:
1244 ax25->modulus = AX25_MODULUS;
1245 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1246 if (ax25->ax25_dev->dama.slave)
1247 ax25_ds_establish_data_link(ax25);
1248 else
1249 ax25_std_establish_data_link(ax25);
1250 break;
1251#endif
1252 }
1253
1254 ax25->state = AX25_STATE_1;
1255
1256 ax25_start_heartbeat(ax25);
1257
1258 /* Now the loop */
1259 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1260 err = -EINPROGRESS;
75606dc6 1261 goto out_release;
1da177e4
LT		 1262 }
1263
1264 if (sk->sk_state == TCP_SYN_SENT) {
75606dc6 1265 DEFINE_WAIT(wait);
1da177e4 1266
1da177e4 1267 for (;;) {
75606dc6 1268 prepare_to_wait(sk->sk_sleep, &wait,
bd3b071b 1269 TASK_INTERRUPTIBLE);
1da177e4
LT		 1270 if (sk->sk_state != TCP_SYN_SENT)
1271 break;
75606dc6
RB		 1272 if (!signal_pending(current)) {
1273 release_sock(sk);
1da177e4
LT		 1274 schedule();
1275 lock_sock(sk);
1276 continue;
1277 }
75606dc6
RB		 1278 err = -ERESTARTSYS;
1279 break;
1da177e4 1280 }
75606dc6
RB		 1281 finish_wait(sk->sk_sleep, &wait);
1282
1283 if (err)
1284 goto out_release;
1da177e4
LT		 1285 }
1286
1287 if (sk->sk_state != TCP_ESTABLISHED) {
1288 /* Not in ABM, not in WAIT_UA -> failed */
1289 sock->state = SS_UNCONNECTED;
1290 err = sock_error(sk); /* Always set at this point */
75606dc6 1291 goto out_release;
1da177e4
LT		 1292 }
1293
1294 sock->state = SS_CONNECTED;
1295
75606dc6
RB		 1296 err = 0;
1297out_release:
1da177e4
LT		 1298 release_sock(sk);
1299
1300 return err;
1301}
1302
1da177e4
LT		 1303static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1304{
1da177e4
LT		 1305 struct sk_buff *skb;
1306 struct sock *newsk;
75606dc6 1307 DEFINE_WAIT(wait);
1da177e4
LT		 1308 struct sock *sk;
1309 int err = 0;
1310
1311 if (sock->state != SS_UNCONNECTED)
1312 return -EINVAL;
1313
1314 if ((sk = sock->sk) == NULL)
1315 return -EINVAL;
1316
1317 lock_sock(sk);
1318 if (sk->sk_type != SOCK_SEQPACKET) {
1319 err = -EOPNOTSUPP;
1320 goto out;
1321 }
1322
1323 if (sk->sk_state != TCP_LISTEN) {
1324 err = -EINVAL;
1325 goto out;
1326 }
1327
1328 /*
1329 * The read queue this time is holding sockets ready to use
1330 * hooked into the SABM we saved
1331 */
1da177e4 1332 for (;;) {
75606dc6 1333 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1da177e4
LT		 1334 skb = skb_dequeue(&sk->sk_receive_queue);
1335 if (skb)
1336 break;
1337
1da177e4 1338 if (flags & O_NONBLOCK) {
75606dc6
RB		 1339 err = -EWOULDBLOCK;
1340 break;
1da177e4 1341 }
75606dc6
RB		 1342 if (!signal_pending(current)) {
1343 release_sock(sk);
1da177e4
LT		 1344 schedule();
1345 lock_sock(sk);
1346 continue;
1347 }
75606dc6
RB		 1348 err = -ERESTARTSYS;
1349 break;
1da177e4 1350 }
75606dc6
RB		 1351 finish_wait(sk->sk_sleep, &wait);
1352
1353 if (err)
1354 goto out;
1da177e4
LT		 1355
1356 newsk = skb->sk;
1357 newsk->sk_socket = newsock;
1358 newsk->sk_sleep = &newsock->wait;
1359
1360 /* Now attach up the new socket */
1361 kfree_skb(skb);
1362 sk->sk_ack_backlog--;
1363 newsock->sk = newsk;
1364 newsock->state = SS_CONNECTED;
1365
1366out:
1367 release_sock(sk);
1368
1369 return err;
1370}
1371
1372static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1373 int *uaddr_len, int peer)
1374{
1375 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1376 struct sock *sk = sock->sk;
1377 unsigned char ndigi, i;
1378 ax25_cb *ax25;
1379 int err = 0;
1380
1381 lock_sock(sk);
1382 ax25 = ax25_sk(sk);
1383
1384 if (peer != 0) {
1385 if (sk->sk_state != TCP_ESTABLISHED) {
1386 err = -ENOTCONN;
1387 goto out;
1388 }
1389
1390 fsa->fsa_ax25.sax25_family = AF_AX25;
1391 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1392 fsa->fsa_ax25.sax25_ndigis = 0;
1393
1394 if (ax25->digipeat != NULL) {
1395 ndigi = ax25->digipeat->ndigi;
1396 fsa->fsa_ax25.sax25_ndigis = ndigi;
1397 for (i = 0; i < ndigi; i++)
1398 fsa->fsa_digipeater[i] =
1399 ax25->digipeat->calls[i];
1400 }
1401 } else {
1402 fsa->fsa_ax25.sax25_family = AF_AX25;
1403 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1404 fsa->fsa_ax25.sax25_ndigis = 1;
1405 if (ax25->ax25_dev != NULL) {
1406 memcpy(&fsa->fsa_digipeater[0],
1407 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1408 } else {
1409 fsa->fsa_digipeater[0] = null_ax25_address;
1410 }
1411 }
1412 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1413
1414out:
1415 release_sock(sk);
1416
1417 return err;
1418}
1419
1420static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1421 struct msghdr *msg, size_t len)
1422{
1423 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1424 struct sock *sk = sock->sk;
1425 struct sockaddr_ax25 sax;
1426 struct sk_buff *skb;
1427 ax25_digi dtmp, *dp;
1da177e4
LT		 1428 ax25_cb *ax25;
1429 size_t size;
1430 int lv, err, addr_len = msg->msg_namelen;
1431
1432 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1433 return -EINVAL;
1434
1435 lock_sock(sk);
1436 ax25 = ax25_sk(sk);
1437
1438 if (sock_flag(sk, SOCK_ZAPPED)) {
1439 err = -EADDRNOTAVAIL;
1440 goto out;
1441 }
1442
1443 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1444 send_sig(SIGPIPE, current, 0);
1445 err = -EPIPE;
1446 goto out;
1447 }
1448
1449 if (ax25->ax25_dev == NULL) {
1450 err = -ENETUNREACH;
1451 goto out;
1452 }
1453
1454 if (len > ax25->ax25_dev->dev->mtu) {
1455 err = -EMSGSIZE;
1456 goto out;
1457 }
528930b9 1458
1da177e4
LT		 1459 if (usax != NULL) {
1460 if (usax->sax25_family != AF_AX25) {
1461 err = -EINVAL;
1462 goto out;
1463 }
1464
1465 if (addr_len == sizeof(struct sockaddr_ax25)) {
1466 printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structure\n",
1467 current->comm);
1468 }
1469 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1470 /* support for old structure may go away some time */
1471 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
528930b9
YH		 1472 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1473 err = -EINVAL;
1da177e4
LT		 1474 goto out;
1475 }
1476
1477 printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n",
1478 current->comm);
1479 }
1480
1481 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1482 int ct = 0;
1483 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1484
1485 /* Valid number of digipeaters ? */
1486 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1487 err = -EINVAL;
1488 goto out;
1489 }
1490
1491 dtmp.ndigi = usax->sax25_ndigis;
1492
1493 while (ct < usax->sax25_ndigis) {
1494 dtmp.repeated[ct] = 0;
1495 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1496 ct++;
1497 }
1498
1499 dtmp.lastrepeat = 0;
1500 }
1501
1502 sax = *usax;
1503 if (sk->sk_type == SOCK_SEQPACKET &&
1504 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1505 err = -EISCONN;
1506 goto out;
1507 }
1508 if (usax->sax25_ndigis == 0)
1509 dp = NULL;
1510 else
1511 dp = &dtmp;
1512 } else {
1513 /*
1514 * FIXME: 1003.1g - if the socket is like this because
1515 * it has become closed (not started closed) and is VC
1516 * we ought to SIGPIPE, EPIPE
1517 */
1518 if (sk->sk_state != TCP_ESTABLISHED) {
1519 err = -ENOTCONN;
1520 goto out;
1521 }
1522 sax.sax25_family = AF_AX25;
1523 sax.sax25_call = ax25->dest_addr;
1524 dp = ax25->digipeat;
1525 }
1526
1527 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1528
1529 /* Build a packet */
1530 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1531
1532 /* Assume the worst case */
1533 size = len + ax25->ax25_dev->dev->hard_header_len;
1534
1535 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1536 if (skb == NULL)
1537 goto out;
1538
1539 skb_reserve(skb, size - len);
1540
1541 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1542
1543 /* User data follows immediately after the AX.25 data */
1544 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1545 err = -EFAULT;
1546 kfree_skb(skb);
1547 goto out;
1548 }
1549
c1d2bbe1 1550 skb_reset_network_header(skb);
1da177e4
LT		 1551
1552 /* Add the PID if one is not supplied by the user in the skb */
967b05f6
ACM		 1553 if (!ax25->pidincl)
1554 *skb_push(skb, 1) = sk->sk_protocol;
1da177e4
LT		 1555
1556 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1557
1558 if (sk->sk_type == SOCK_SEQPACKET) {
1559 /* Connected mode sockets go via the LAPB machine */
1560 if (sk->sk_state != TCP_ESTABLISHED) {
1561 kfree_skb(skb);
1562 err = -ENOTCONN;
1563 goto out;
1564 }
1565
1566 /* Shove it onto the queue and kick */
1567 ax25_output(ax25, ax25->paclen, skb);
1568
1569 err = len;
1570 goto out;
1571 }
1572
967b05f6 1573 skb_push(skb, 1 + ax25_addr_size(dp));
1da177e4
LT		 1574
1575 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1576
1577 if (dp != NULL)
1578 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1579
1580 /* Build an AX.25 header */
967b05f6
ACM		 1581 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1582 dp, AX25_COMMAND, AX25_MODULUS);
1da177e4
LT		 1583
1584 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1585
967b05f6 1586 skb_set_transport_header(skb, lv);
1da177e4 1587
9c70220b
ACM		 1588 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1589 skb->data, skb_transport_header(skb));
1da177e4 1590
9c70220b 1591 *skb_transport_header(skb) = AX25_UI;
1da177e4
LT		 1592
1593 /* Datagram frames go straight out of the door as UI */
29c4be51 1594 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1da177e4
LT		 1595
1596 err = len;
1597
1598out:
1599 release_sock(sk);
1600
1601 return err;
1602}
1603
1604static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1605 struct msghdr *msg, size_t size, int flags)
1606{
1607 struct sock *sk = sock->sk;
1608 struct sk_buff *skb;
1609 int copied;
1610 int err = 0;
1611
1612 lock_sock(sk);
1613 /*
1614 * This works for seqpacket too. The receiver has ordered the
1615 * queue for us! We do one quick check first though
1616 */
1617 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1618 err = -ENOTCONN;
1619 goto out;
1620 }
1621
1622 /* Now we can treat all alike */
1623 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
528930b9 1624 flags & MSG_DONTWAIT, &err);
1da177e4
LT		 1625 if (skb == NULL)
1626 goto out;
1627
1628 if (!ax25_sk(sk)->pidincl)
1629 skb_pull(skb, 1); /* Remove PID */
1630
badff6d0
ACM		 1631 skb_reset_transport_header(skb);
1632 copied = skb->len;
1da177e4
LT		 1633
1634 if (copied > size) {
1635 copied = size;
1636 msg->msg_flags |= MSG_TRUNC;
1637 }
1638
1639 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1640
1641 if (msg->msg_namelen != 0) {
1642 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1643 ax25_digi digi;
1644 ax25_address src;
98e399f8 1645 const unsigned char *mac = skb_mac_header(skb);
1da177e4 1646
98e399f8
ACM		 1647 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1648 &digi, NULL, NULL);
1da177e4
LT		 1649 sax->sax25_family = AF_AX25;
1650 /* We set this correctly, even though we may not let the
1651 application know the digi calls further down (because it
1652 did NOT ask to know them). This could get political... **/
1653 sax->sax25_ndigis = digi.ndigi;
1654 sax->sax25_call = src;
1655
1656 if (sax->sax25_ndigis != 0) {
1657 int ct;
1658 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1659
1660 for (ct = 0; ct < digi.ndigi; ct++)
1661 fsa->fsa_digipeater[ct] = digi.calls[ct];
1662 }
1663 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1664 }
1665
1666 skb_free_datagram(sk, skb);
1667 err = copied;
1668
1669out:
1670 release_sock(sk);
1671
1672 return err;
1673}
1674
1675static int ax25_shutdown(struct socket *sk, int how)
1676{
1677 /* FIXME - generate DM and RNR states */
1678 return -EOPNOTSUPP;
1679}
1680
1681static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1682{
1683 struct sock *sk = sock->sk;
1684 void __user *argp = (void __user *)arg;
1685 int res = 0;
1686
1687 lock_sock(sk);
1688 switch (cmd) {
1689 case TIOCOUTQ: {
1690 long amount;
1691 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1692 if (amount < 0)
1693 amount = 0;
1694 res = put_user(amount, (int __user *)argp);
1695 break;
1696 }
1697
1698 case TIOCINQ: {
1699 struct sk_buff *skb;
1700 long amount = 0L;
1701 /* These two are safe on a single CPU system as only user tasks fiddle here */
1702 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1703 amount = skb->len;
20b7d10a 1704 res = put_user(amount, (int __user *) argp);
1da177e4
LT		 1705 break;
1706 }
1707
1708 case SIOCGSTAMP:
9b37ee75 1709 res = sock_get_timestamp(sk, argp);
1da177e4
LT		 1710 break;
1711
ae40eb1e
ED		 1712 case SIOCGSTAMPNS:
1713 res = sock_get_timestampns(sk, argp);
1714 break;
1715
1da177e4
LT		 1716 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1717 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1718 case SIOCAX25GETUID: {
1719 struct sockaddr_ax25 sax25;
1720 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1721 res = -EFAULT;
1722 break;
1723 }
1724 res = ax25_uid_ioctl(cmd, &sax25);
1725 break;
1726 }
1727
1728 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1729 long amount;
1730 if (!capable(CAP_NET_ADMIN)) {
1731 res = -EPERM;
1732 break;
1733 }
1734 if (get_user(amount, (long __user *)argp)) {
1735 res = -EFAULT;
1736 break;
1737 }
1738 if (amount > AX25_NOUID_BLOCK) {
1739 res = -EINVAL;
1740 break;
1741 }
1742 ax25_uid_policy = amount;
1743 res = 0;
1744 break;
1745 }
1746
1747 case SIOCADDRT:
1748 case SIOCDELRT:
1749 case SIOCAX25OPTRT:
1750 if (!capable(CAP_NET_ADMIN)) {
1751 res = -EPERM;
1752 break;
1753 }
1754 res = ax25_rt_ioctl(cmd, argp);
1755 break;
1756
1757 case SIOCAX25CTLCON:
1758 if (!capable(CAP_NET_ADMIN)) {
1759 res = -EPERM;
1760 break;
1761 }
1762 res = ax25_ctl_ioctl(cmd, argp);
1763 break;
1764
1765 case SIOCAX25GETINFO:
1766 case SIOCAX25GETINFOOLD: {
1767 ax25_cb *ax25 = ax25_sk(sk);
1768 struct ax25_info_struct ax25_info;
1769
1770 ax25_info.t1 = ax25->t1 / HZ;
1771 ax25_info.t2 = ax25->t2 / HZ;
1772 ax25_info.t3 = ax25->t3 / HZ;
1773 ax25_info.idle = ax25->idle / (60 * HZ);
1774 ax25_info.n2 = ax25->n2;
1775 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1776 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1777 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1778 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1779 ax25_info.n2count = ax25->n2count;
1780 ax25_info.state = ax25->state;
1781 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1782 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
1783 ax25_info.vs = ax25->vs;
1784 ax25_info.vr = ax25->vr;
1785 ax25_info.va = ax25->va;
1786 ax25_info.vs_max = ax25->vs; /* reserved */
1787 ax25_info.paclen = ax25->paclen;
1788 ax25_info.window = ax25->window;
1789
1790 /* old structure? */
1791 if (cmd == SIOCAX25GETINFOOLD) {
1792 static int warned = 0;
1793 if (!warned) {
1794 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1795 current->comm);
1796 warned=1;
1797 }
1798
1799 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1800 res = -EFAULT;
1801 break;
1802 }
1803 } else {
1804 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1805 res = -EINVAL;
1806 break;
1807 }
1808 }
1809 res = 0;
1810 break;
1811 }
1812
1813 case SIOCAX25ADDFWD:
1814 case SIOCAX25DELFWD: {
1815 struct ax25_fwd_struct ax25_fwd;
1816 if (!capable(CAP_NET_ADMIN)) {
1817 res = -EPERM;
1818 break;
1819 }
1820 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1821 res = -EFAULT;
1822 break;
1823 }
1824 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1825 break;
1826 }
1827
1828 case SIOCGIFADDR:
1829 case SIOCSIFADDR:
1830 case SIOCGIFDSTADDR:
1831 case SIOCSIFDSTADDR:
1832 case SIOCGIFBRDADDR:
1833 case SIOCSIFBRDADDR:
1834 case SIOCGIFNETMASK:
1835 case SIOCSIFNETMASK:
1836 case SIOCGIFMETRIC:
1837 case SIOCSIFMETRIC:
1838 res = -EINVAL;
1839 break;
1840
1841 default:
b5e5fa5e 1842 res = -ENOIOCTLCMD;
1da177e4
LT		 1843 break;
1844 }
1845 release_sock(sk);
1846
1847 return res;
1848}
1849
1850#ifdef CONFIG_PROC_FS
1851
1852static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1853{
1854 struct ax25_cb *ax25;
1855 struct hlist_node *node;
1856 int i = 0;
1857
1858 spin_lock_bh(&ax25_list_lock);
1859 ax25_for_each(ax25, node, &ax25_list) {
1860 if (i == *pos)
1861 return ax25;
1862 ++i;
1863 }
1864 return NULL;
1865}
1866
1867static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1868{
1869 ++*pos;
1870
1871 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1872 struct ax25_cb, ax25_node);
1873}
528930b9 1874
1da177e4
LT		 1875static void ax25_info_stop(struct seq_file *seq, void *v)
1876{
1877 spin_unlock_bh(&ax25_list_lock);
1878}
1879
1880static int ax25_info_show(struct seq_file *seq, void *v)
1881{
1882 ax25_cb *ax25 = v;
f75268cd 1883 char buf[11];
1da177e4
LT		 1884 int k;
1885
1886
1887 /*
1888 * New format:
1889 * magic dev src_addr dest_addr,digi1,digi2,.. st vs vr va t1 t1 t2 t2 t3 t3 idle idle n2 n2 rtt window paclen Snd-Q Rcv-Q inode
1890 */
1891
1892 seq_printf(seq, "%8.8lx %s %s%s ",
1893 (long) ax25,
1894 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
f75268cd 1895 ax2asc(buf, &ax25->source_addr),
1da177e4 1896 ax25->iamdigi? "*":"");
f75268cd 1897 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1da177e4
LT		 1898
1899 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1900 seq_printf(seq, ",%s%s",
f75268cd 1901 ax2asc(buf, &ax25->digipeat->calls[k]),
1da177e4
LT		 1902 ax25->digipeat->repeated[k]? "*":"");
1903 }
1904
1905 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1906 ax25->state,
1907 ax25->vs, ax25->vr, ax25->va,
1908 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1909 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1910 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1911 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1912 ax25->idle / (60 * HZ),
1913 ax25->n2count, ax25->n2,
1914 ax25->rtt / HZ,
1915 ax25->window,
1916 ax25->paclen);
1917
1918 if (ax25->sk != NULL) {
1919 bh_lock_sock(ax25->sk);
1920 seq_printf(seq," %d %d %ld\n",
1921 atomic_read(&ax25->sk->sk_wmem_alloc),
1922 atomic_read(&ax25->sk->sk_rmem_alloc),
1923 ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L);
1924 bh_unlock_sock(ax25->sk);
1925 } else {
1926 seq_puts(seq, " * * *\n");
1927 }
1928 return 0;
1929}
1930
56b3d975 1931static const struct seq_operations ax25_info_seqops = {
1da177e4
LT		 1932 .start = ax25_info_start,
1933 .next = ax25_info_next,
1934 .stop = ax25_info_stop,
1935 .show = ax25_info_show,
1936};
1937
1938static int ax25_info_open(struct inode *inode, struct file *file)
1939{
1940 return seq_open(file, &ax25_info_seqops);
1941}
1942
9a32144e 1943static const struct file_operations ax25_info_fops = {
1da177e4
LT		 1944 .owner = THIS_MODULE,
1945 .open = ax25_info_open,
1946 .read = seq_read,
1947 .llseek = seq_lseek,
1948 .release = seq_release,
1949};
1950
1951#endif
1952
1953static struct net_proto_family ax25_family_ops = {
1954 .family = PF_AX25,
1955 .create = ax25_create,
1956 .owner = THIS_MODULE,
1957};
1958
90ddc4f0 1959static const struct proto_ops ax25_proto_ops = {
4676356b
RB		 1960 .family = PF_AX25,
1961 .owner = THIS_MODULE,
1962 .release = ax25_release,
1963 .bind = ax25_bind,
1964 .connect = ax25_connect,
1965 .socketpair = sock_no_socketpair,
1966 .accept = ax25_accept,
1967 .getname = ax25_getname,
1968 .poll = datagram_poll,
1969 .ioctl = ax25_ioctl,
1970 .listen = ax25_listen,
1971 .shutdown = ax25_shutdown,
1972 .setsockopt = ax25_setsockopt,
1973 .getsockopt = ax25_getsockopt,
1974 .sendmsg = ax25_sendmsg,
1975 .recvmsg = ax25_recvmsg,
1976 .mmap = sock_no_mmap,
1977 .sendpage = sock_no_sendpage,
1da177e4
LT		 1978};
1979
1980/*
1981 * Called by socket.c on kernel start up
1982 */
1983static struct packet_type ax25_packet_type = {
1984 .type = __constant_htons(ETH_P_AX25),
1985 .dev = NULL, /* All devices */
1986 .func = ax25_kiss_rcv,
1987};
1988
1989static struct notifier_block ax25_dev_notifier = {
1990 .notifier_call =ax25_device_event,
1991};
1992
1da177e4
LT		 1993static int __init ax25_init(void)
1994{
1995 int rc = proto_register(&ax25_proto, 0);
1996
1997 if (rc != 0)
1998 goto out;
1999
2000 sock_register(&ax25_family_ops);
2001 dev_add_pack(&ax25_packet_type);
2002 register_netdevice_notifier(&ax25_dev_notifier);
2003 ax25_register_sysctl();
2004
457c4cbc
EB		 2005 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2006 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2007 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
1da177e4
LT		 2008out:
2009 return rc;
2010}
2011module_init(ax25_init);
2012
2013
2014MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2015MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2016MODULE_LICENSE("GPL");
2017MODULE_ALIAS_NETPROTO(PF_AX25);
2018
2019static void __exit ax25_exit(void)
2020{
457c4cbc
EB		 2021 proc_net_remove(&init_net, "ax25_route");
2022 proc_net_remove(&init_net, "ax25");
2023 proc_net_remove(&init_net, "ax25_calls");
1da177e4
LT		 2024 ax25_rt_free();
2025 ax25_uid_free();
2026 ax25_dev_free();
2027
2028 ax25_unregister_sysctl();
2029 unregister_netdevice_notifier(&ax25_dev_notifier);
2030
2031 dev_remove_pack(&ax25_packet_type);
2032
2033 sock_unregister(PF_AX25);
2034 proto_unregister(&ax25_proto);
2035}
2036module_exit(ax25_exit);
kernel source for telekom puls (alcatel/mediatek)