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.
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)
16 #include <linux/capability.h>
17 #include <linux/module.h>
18 #include <linux/errno.h>
19 #include <linux/types.h>
20 #include <linux/socket.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
29 #include <linux/inet.h>
30 #include <linux/netdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/skbuff.h>
34 #include <asm/uaccess.h>
35 #include <asm/system.h>
36 #include <linux/fcntl.h>
37 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
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>
47 #include <net/net_namespace.h>
48 #include <net/tcp_states.h>
54 HLIST_HEAD(ax25_list);
55 DEFINE_SPINLOCK(ax25_list_lock);
57 static const struct proto_ops ax25_proto_ops;
59 static void ax25_free_sock(struct sock *sk)
61 ax25_cb_put(ax25_sk(sk));
65 * Socket removal during an interrupt is now safe.
67 static void ax25_cb_del(ax25_cb *ax25)
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);
78 * Kill all bound sockets on a dropped device.
80 static void ax25_kill_by_device(struct net_device *dev)
84 struct hlist_node *node;
86 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
89 spin_lock_bh(&ax25_list_lock);
91 ax25_for_each(s, node, &ax25_list) {
92 if (s->ax25_dev == ax25_dev) {
94 spin_unlock_bh(&ax25_list_lock);
95 ax25_disconnect(s, ENETUNREACH);
96 spin_lock_bh(&ax25_list_lock);
98 /* The entry could have been deleted from the
99 * list meanwhile and thus the next pointer is
100 * no longer valid. Play it safe and restart
101 * the scan. Forward progress is ensured
102 * because we set s->ax25_dev to NULL and we
103 * are never passed a NULL 'dev' argument.
108 spin_unlock_bh(&ax25_list_lock);
112 * Handle device status changes.
114 static int ax25_device_event(struct notifier_block *this, unsigned long event,
117 struct net_device *dev = (struct net_device *)ptr;
119 if (!net_eq(dev_net(dev), &init_net))
122 /* Reject non AX.25 devices */
123 if (dev->type != ARPHRD_AX25)
128 ax25_dev_device_up(dev);
131 ax25_kill_by_device(dev);
132 ax25_rt_device_down(dev);
133 ax25_dev_device_down(dev);
143 * Add a socket to the bound sockets list.
145 void ax25_cb_add(ax25_cb *ax25)
147 spin_lock_bh(&ax25_list_lock);
149 hlist_add_head(&ax25->ax25_node, &ax25_list);
150 spin_unlock_bh(&ax25_list_lock);
154 * Find a socket that wants to accept the SABM we have just
157 struct sock *ax25_find_listener(ax25_address *addr, int digi,
158 struct net_device *dev, int type)
161 struct hlist_node *node;
163 spin_lock(&ax25_list_lock);
164 ax25_for_each(s, node, &ax25_list) {
165 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
167 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
168 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
169 /* If device is null we match any device */
170 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
172 spin_unlock(&ax25_list_lock);
177 spin_unlock(&ax25_list_lock);
183 * Find an AX.25 socket given both ends.
185 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
188 struct sock *sk = NULL;
190 struct hlist_node *node;
192 spin_lock(&ax25_list_lock);
193 ax25_for_each(s, node, &ax25_list) {
194 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
195 !ax25cmp(&s->dest_addr, dest_addr) &&
196 s->sk->sk_type == type) {
203 spin_unlock(&ax25_list_lock);
209 * Find an AX.25 control block given both ends. It will only pick up
210 * floating AX.25 control blocks or non Raw socket bound control blocks.
212 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
213 ax25_digi *digi, struct net_device *dev)
216 struct hlist_node *node;
218 spin_lock_bh(&ax25_list_lock);
219 ax25_for_each(s, node, &ax25_list) {
220 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
222 if (s->ax25_dev == NULL)
224 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
225 if (digi != NULL && digi->ndigi != 0) {
226 if (s->digipeat == NULL)
228 if (ax25digicmp(s->digipeat, digi) != 0)
231 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
235 spin_unlock_bh(&ax25_list_lock);
240 spin_unlock_bh(&ax25_list_lock);
245 EXPORT_SYMBOL(ax25_find_cb);
247 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
250 struct sk_buff *copy;
251 struct hlist_node *node;
253 spin_lock(&ax25_list_lock);
254 ax25_for_each(s, node, &ax25_list) {
255 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
256 s->sk->sk_type == SOCK_RAW &&
257 s->sk->sk_protocol == proto &&
258 s->ax25_dev->dev == skb->dev &&
259 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
260 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
262 if (sock_queue_rcv_skb(s->sk, copy) != 0)
266 spin_unlock(&ax25_list_lock);
272 void ax25_destroy_socket(ax25_cb *);
275 * Handler for deferred kills.
277 static void ax25_destroy_timer(unsigned long data)
279 ax25_cb *ax25=(ax25_cb *)data;
286 ax25_destroy_socket(ax25);
292 * This is called from user mode and the timers. Thus it protects itself
293 * against interrupt users but doesn't worry about being called during
294 * work. Once it is removed from the queue no interrupt or bottom half
295 * will touch it and we are (fairly 8-) ) safe.
297 void ax25_destroy_socket(ax25_cb *ax25)
303 ax25_stop_heartbeat(ax25);
304 ax25_stop_t1timer(ax25);
305 ax25_stop_t2timer(ax25);
306 ax25_stop_t3timer(ax25);
307 ax25_stop_idletimer(ax25);
309 ax25_clear_queues(ax25); /* Flush the queues */
311 if (ax25->sk != NULL) {
312 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
313 if (skb->sk != ax25->sk) {
314 /* A pending connection */
315 ax25_cb *sax25 = ax25_sk(skb->sk);
317 /* Queue the unaccepted socket for death */
318 sock_orphan(skb->sk);
320 /* 9A4GL: hack to release unaccepted sockets */
321 skb->sk->sk_state = TCP_LISTEN;
323 ax25_start_heartbeat(sax25);
324 sax25->state = AX25_STATE_0;
329 skb_queue_purge(&ax25->sk->sk_write_queue);
332 if (ax25->sk != NULL) {
333 if (sk_has_allocations(ax25->sk)) {
334 /* Defer: outstanding buffers */
335 setup_timer(&ax25->dtimer, ax25_destroy_timer,
336 (unsigned long)ax25);
337 ax25->dtimer.expires = jiffies + 2 * HZ;
338 add_timer(&ax25->dtimer);
340 struct sock *sk=ax25->sk;
350 * dl1bke 960311: set parameters for existing AX.25 connections,
351 * includes a KILL command to abort any connection.
352 * VERY useful for debugging ;-)
354 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
356 struct ax25_ctl_struct ax25_ctl;
362 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
365 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
368 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
371 digi.ndigi = ax25_ctl.digi_count;
372 for (k = 0; k < digi.ndigi; k++)
373 digi.calls[k] = ax25_ctl.digi_addr[k];
375 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
378 switch (ax25_ctl.cmd) {
380 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
381 #ifdef CONFIG_AX25_DAMA_SLAVE
382 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
385 ax25_disconnect(ax25, ENETRESET);
389 if (ax25->modulus == AX25_MODULUS) {
390 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
393 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
396 ax25->window = ax25_ctl.arg;
400 if (ax25_ctl.arg < 1)
402 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
403 ax25->t1 = ax25_ctl.arg * HZ;
407 if (ax25_ctl.arg < 1)
409 ax25->t2 = ax25_ctl.arg * HZ;
413 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
416 ax25->n2 = ax25_ctl.arg;
420 if (ax25_ctl.arg < 0)
422 ax25->t3 = ax25_ctl.arg * HZ;
426 if (ax25_ctl.arg < 0)
428 ax25->idle = ax25_ctl.arg * 60 * HZ;
432 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
434 ax25->paclen = ax25_ctl.arg;
444 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
446 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
447 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
448 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
449 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
450 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
451 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
452 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
453 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
455 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
456 ax25->modulus = AX25_EMODULUS;
457 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
459 ax25->modulus = AX25_MODULUS;
460 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
465 * Fill in a created AX.25 created control block with the default
466 * values for a particular device.
468 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
470 ax25->ax25_dev = ax25_dev;
472 if (ax25->ax25_dev != NULL) {
473 ax25_fillin_cb_from_dev(ax25, ax25_dev);
478 * No device, use kernel / AX.25 spec default values
480 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
481 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
482 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
483 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
484 ax25->n2 = AX25_DEF_N2;
485 ax25->paclen = AX25_DEF_PACLEN;
486 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
487 ax25->backoff = AX25_DEF_BACKOFF;
489 if (AX25_DEF_AXDEFMODE) {
490 ax25->modulus = AX25_EMODULUS;
491 ax25->window = AX25_DEF_EWINDOW;
493 ax25->modulus = AX25_MODULUS;
494 ax25->window = AX25_DEF_WINDOW;
499 * Create an empty AX.25 control block.
501 ax25_cb *ax25_create_cb(void)
505 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
508 atomic_set(&ax25->refcount, 1);
510 skb_queue_head_init(&ax25->write_queue);
511 skb_queue_head_init(&ax25->frag_queue);
512 skb_queue_head_init(&ax25->ack_queue);
513 skb_queue_head_init(&ax25->reseq_queue);
515 ax25_setup_timers(ax25);
517 ax25_fillin_cb(ax25, NULL);
519 ax25->state = AX25_STATE_0;
525 * Handling for system calls applied via the various interfaces to an
529 static int ax25_setsockopt(struct socket *sock, int level, int optname,
530 char __user *optval, int optlen)
532 struct sock *sk = sock->sk;
534 struct net_device *dev;
535 char devname[IFNAMSIZ];
538 if (level != SOL_AX25)
541 if (optlen < sizeof(int))
544 if (get_user(opt, (int __user *)optval))
552 if (ax25->modulus == AX25_MODULUS) {
553 if (opt < 1 || opt > 7) {
558 if (opt < 1 || opt > 63) {
571 ax25->rtt = (opt * HZ) >> 1;
584 if (opt < 1 || opt > 31) {
604 ax25->idle = opt * 60 * HZ;
608 if (opt < 0 || opt > 2) {
616 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
620 ax25->pidincl = opt ? 1 : 0;
624 ax25->iamdigi = opt ? 1 : 0;
628 if (opt < 16 || opt > 65535) {
635 case SO_BINDTODEVICE:
636 if (optlen > IFNAMSIZ)
638 if (copy_from_user(devname, optval, optlen)) {
643 dev = dev_get_by_name(&init_net, devname);
649 if (sk->sk_type == SOCK_SEQPACKET &&
650 (sock->state != SS_UNCONNECTED ||
651 sk->sk_state == TCP_LISTEN)) {
652 res = -EADDRNOTAVAIL;
657 ax25->ax25_dev = ax25_dev_ax25dev(dev);
658 ax25_fillin_cb(ax25, ax25->ax25_dev);
669 static int ax25_getsockopt(struct socket *sock, int level, int optname,
670 char __user *optval, int __user *optlen)
672 struct sock *sk = sock->sk;
674 struct ax25_dev *ax25_dev;
675 char devname[IFNAMSIZ];
680 if (level != SOL_AX25)
683 if (get_user(maxlen, optlen))
689 valptr = (void *) &val;
690 length = min_t(unsigned int, maxlen, sizeof(int));
717 val = ax25->idle / (60 * HZ);
725 val = (ax25->modulus == AX25_EMODULUS);
740 case SO_BINDTODEVICE:
741 ax25_dev = ax25->ax25_dev;
743 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
744 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
745 length = strlen(devname) + 1;
751 valptr = (void *) devname;
760 if (put_user(length, optlen))
763 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
766 static int ax25_listen(struct socket *sock, int backlog)
768 struct sock *sk = sock->sk;
772 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
773 sk->sk_max_ack_backlog = backlog;
774 sk->sk_state = TCP_LISTEN;
786 * XXX: when creating ax25_sock we should update the .obj_size setting
789 static struct proto ax25_proto = {
791 .owner = THIS_MODULE,
792 .obj_size = sizeof(struct sock),
795 static int ax25_create(struct net *net, struct socket *sock, int protocol)
800 if (net != &init_net)
801 return -EAFNOSUPPORT;
803 switch (sock->type) {
805 if (protocol == 0 || protocol == PF_AX25)
806 protocol = AX25_P_TEXT;
812 case PF_AX25: /* For CLX */
813 protocol = AX25_P_TEXT;
826 return -ESOCKTNOSUPPORT;
827 #ifdef CONFIG_NETROM_MODULE
829 if (ax25_protocol_is_registered(AX25_P_NETROM))
830 return -ESOCKTNOSUPPORT;
832 #ifdef CONFIG_ROSE_MODULE
834 if (ax25_protocol_is_registered(AX25_P_ROSE))
835 return -ESOCKTNOSUPPORT;
845 return -ESOCKTNOSUPPORT;
848 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
852 ax25 = sk->sk_protinfo = ax25_create_cb();
858 sock_init_data(sock, sk);
860 sk->sk_destruct = ax25_free_sock;
861 sock->ops = &ax25_proto_ops;
862 sk->sk_protocol = protocol;
869 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
872 ax25_cb *ax25, *oax25;
874 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
878 if ((ax25 = ax25_create_cb()) == NULL) {
883 switch (osk->sk_type) {
894 sock_init_data(NULL, sk);
896 sk->sk_destruct = ax25_free_sock;
897 sk->sk_type = osk->sk_type;
898 sk->sk_priority = osk->sk_priority;
899 sk->sk_protocol = osk->sk_protocol;
900 sk->sk_rcvbuf = osk->sk_rcvbuf;
901 sk->sk_sndbuf = osk->sk_sndbuf;
902 sk->sk_state = TCP_ESTABLISHED;
903 sock_copy_flags(sk, osk);
905 oax25 = ax25_sk(osk);
907 ax25->modulus = oax25->modulus;
908 ax25->backoff = oax25->backoff;
909 ax25->pidincl = oax25->pidincl;
910 ax25->iamdigi = oax25->iamdigi;
911 ax25->rtt = oax25->rtt;
912 ax25->t1 = oax25->t1;
913 ax25->t2 = oax25->t2;
914 ax25->t3 = oax25->t3;
915 ax25->n2 = oax25->n2;
916 ax25->idle = oax25->idle;
917 ax25->paclen = oax25->paclen;
918 ax25->window = oax25->window;
920 ax25->ax25_dev = ax25_dev;
921 ax25->source_addr = oax25->source_addr;
923 if (oax25->digipeat != NULL) {
924 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
926 if (ax25->digipeat == NULL) {
933 sk->sk_protinfo = ax25;
939 static int ax25_release(struct socket *sock)
941 struct sock *sk = sock->sk;
952 if (sk->sk_type == SOCK_SEQPACKET) {
953 switch (ax25->state) {
956 ax25_disconnect(ax25, 0);
958 ax25_destroy_socket(ax25);
963 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
965 ax25_disconnect(ax25, 0);
967 ax25_destroy_socket(ax25);
972 ax25_clear_queues(ax25);
975 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
976 case AX25_PROTO_STD_SIMPLEX:
977 case AX25_PROTO_STD_DUPLEX:
978 ax25_send_control(ax25,
982 ax25_stop_t2timer(ax25);
983 ax25_stop_t3timer(ax25);
984 ax25_stop_idletimer(ax25);
986 #ifdef CONFIG_AX25_DAMA_SLAVE
987 case AX25_PROTO_DAMA_SLAVE:
988 ax25_stop_t3timer(ax25);
989 ax25_stop_idletimer(ax25);
993 ax25_calculate_t1(ax25);
994 ax25_start_t1timer(ax25);
995 ax25->state = AX25_STATE_2;
996 sk->sk_state = TCP_CLOSE;
997 sk->sk_shutdown |= SEND_SHUTDOWN;
998 sk->sk_state_change(sk);
999 sock_set_flag(sk, SOCK_DESTROY);
1006 sk->sk_state = TCP_CLOSE;
1007 sk->sk_shutdown |= SEND_SHUTDOWN;
1008 sk->sk_state_change(sk);
1009 ax25_destroy_socket(ax25);
1020 * We support a funny extension here so you can (as root) give any callsign
1021 * digipeated via a local address as source. This hack is obsolete now
1022 * that we've implemented support for SO_BINDTODEVICE. It is however small
1023 * and trivially backward compatible.
1025 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1027 struct sock *sk = sock->sk;
1028 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1029 ax25_dev *ax25_dev = NULL;
1030 ax25_uid_assoc *user;
1035 if (addr_len != sizeof(struct sockaddr_ax25) &&
1036 addr_len != sizeof(struct full_sockaddr_ax25))
1037 /* support for old structure may go away some time
1038 * ax25_bind(): uses old (6 digipeater) socket structure.
1040 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1041 (addr_len > sizeof(struct full_sockaddr_ax25)))
1044 if (addr->fsa_ax25.sax25_family != AF_AX25)
1047 user = ax25_findbyuid(current_euid());
1052 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1055 call = addr->fsa_ax25.sax25_call;
1061 if (!sock_flag(sk, SOCK_ZAPPED)) {
1066 ax25->source_addr = call;
1069 * User already set interface with SO_BINDTODEVICE
1071 if (ax25->ax25_dev != NULL)
1074 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1075 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1076 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1077 err = -EADDRNOTAVAIL;
1081 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1082 err = -EADDRNOTAVAIL;
1087 if (ax25_dev != NULL)
1088 ax25_fillin_cb(ax25, ax25_dev);
1092 sock_reset_flag(sk, SOCK_ZAPPED);
1101 * FIXME: nonblock behaviour looks like it may have a bug.
1103 static int __must_check ax25_connect(struct socket *sock,
1104 struct sockaddr *uaddr, int addr_len, int flags)
1106 struct sock *sk = sock->sk;
1107 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1108 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1109 ax25_digi *digi = NULL;
1110 int ct = 0, err = 0;
1113 * some sanity checks. code further down depends on this
1116 if (addr_len == sizeof(struct sockaddr_ax25))
1117 /* support for this will go away in early 2.5.x
1118 * ax25_connect(): uses obsolete socket structure
1121 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1122 /* support for old structure may go away some time
1123 * ax25_connect(): uses old (6 digipeater) socket structure.
1125 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1126 (addr_len > sizeof(struct full_sockaddr_ax25)))
1130 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1135 /* deal with restarts */
1136 if (sock->state == SS_CONNECTING) {
1137 switch (sk->sk_state) {
1138 case TCP_SYN_SENT: /* still trying */
1142 case TCP_ESTABLISHED: /* connection established */
1143 sock->state = SS_CONNECTED;
1146 case TCP_CLOSE: /* connection refused */
1147 sock->state = SS_UNCONNECTED;
1148 err = -ECONNREFUSED;
1153 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1154 err = -EISCONN; /* No reconnect on a seqpacket socket */
1158 sk->sk_state = TCP_CLOSE;
1159 sock->state = SS_UNCONNECTED;
1161 kfree(ax25->digipeat);
1162 ax25->digipeat = NULL;
1165 * Handle digi-peaters to be used.
1167 if (addr_len > sizeof(struct sockaddr_ax25) &&
1168 fsa->fsa_ax25.sax25_ndigis != 0) {
1169 /* Valid number of digipeaters ? */
1170 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1175 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1180 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1181 digi->lastrepeat = -1;
1183 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1184 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1185 AX25_HBIT) && ax25->iamdigi) {
1186 digi->repeated[ct] = 1;
1187 digi->lastrepeat = ct;
1189 digi->repeated[ct] = 0;
1191 digi->calls[ct] = fsa->fsa_digipeater[ct];
1197 * Must bind first - autobinding in this may or may not work. If
1198 * the socket is already bound, check to see if the device has
1199 * been filled in, error if it hasn't.
1201 if (sock_flag(sk, SOCK_ZAPPED)) {
1202 /* check if we can remove this feature. It is broken. */
1203 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1205 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1210 ax25_fillin_cb(ax25, ax25->ax25_dev);
1213 if (ax25->ax25_dev == NULL) {
1215 err = -EHOSTUNREACH;
1220 if (sk->sk_type == SOCK_SEQPACKET &&
1221 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1222 ax25->ax25_dev->dev))) {
1224 err = -EADDRINUSE; /* Already such a connection */
1229 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1230 ax25->digipeat = digi;
1232 /* First the easy one */
1233 if (sk->sk_type != SOCK_SEQPACKET) {
1234 sock->state = SS_CONNECTED;
1235 sk->sk_state = TCP_ESTABLISHED;
1239 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1240 sock->state = SS_CONNECTING;
1241 sk->sk_state = TCP_SYN_SENT;
1243 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1244 case AX25_PROTO_STD_SIMPLEX:
1245 case AX25_PROTO_STD_DUPLEX:
1246 ax25_std_establish_data_link(ax25);
1249 #ifdef CONFIG_AX25_DAMA_SLAVE
1250 case AX25_PROTO_DAMA_SLAVE:
1251 ax25->modulus = AX25_MODULUS;
1252 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1253 if (ax25->ax25_dev->dama.slave)
1254 ax25_ds_establish_data_link(ax25);
1256 ax25_std_establish_data_link(ax25);
1261 ax25->state = AX25_STATE_1;
1263 ax25_start_heartbeat(ax25);
1266 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1271 if (sk->sk_state == TCP_SYN_SENT) {
1275 prepare_to_wait(sk->sk_sleep, &wait,
1276 TASK_INTERRUPTIBLE);
1277 if (sk->sk_state != TCP_SYN_SENT)
1279 if (!signal_pending(current)) {
1288 finish_wait(sk->sk_sleep, &wait);
1294 if (sk->sk_state != TCP_ESTABLISHED) {
1295 /* Not in ABM, not in WAIT_UA -> failed */
1296 sock->state = SS_UNCONNECTED;
1297 err = sock_error(sk); /* Always set at this point */
1301 sock->state = SS_CONNECTED;
1310 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1312 struct sk_buff *skb;
1318 if (sock->state != SS_UNCONNECTED)
1321 if ((sk = sock->sk) == NULL)
1325 if (sk->sk_type != SOCK_SEQPACKET) {
1330 if (sk->sk_state != TCP_LISTEN) {
1336 * The read queue this time is holding sockets ready to use
1337 * hooked into the SABM we saved
1340 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1341 skb = skb_dequeue(&sk->sk_receive_queue);
1345 if (flags & O_NONBLOCK) {
1349 if (!signal_pending(current)) {
1358 finish_wait(sk->sk_sleep, &wait);
1364 sock_graft(newsk, newsock);
1366 /* Now attach up the new socket */
1368 sk->sk_ack_backlog--;
1369 newsock->state = SS_CONNECTED;
1377 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1378 int *uaddr_len, int peer)
1380 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1381 struct sock *sk = sock->sk;
1382 unsigned char ndigi, i;
1390 if (sk->sk_state != TCP_ESTABLISHED) {
1395 fsa->fsa_ax25.sax25_family = AF_AX25;
1396 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1397 fsa->fsa_ax25.sax25_ndigis = 0;
1399 if (ax25->digipeat != NULL) {
1400 ndigi = ax25->digipeat->ndigi;
1401 fsa->fsa_ax25.sax25_ndigis = ndigi;
1402 for (i = 0; i < ndigi; i++)
1403 fsa->fsa_digipeater[i] =
1404 ax25->digipeat->calls[i];
1407 fsa->fsa_ax25.sax25_family = AF_AX25;
1408 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1409 fsa->fsa_ax25.sax25_ndigis = 1;
1410 if (ax25->ax25_dev != NULL) {
1411 memcpy(&fsa->fsa_digipeater[0],
1412 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1414 fsa->fsa_digipeater[0] = null_ax25_address;
1417 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1425 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1426 struct msghdr *msg, size_t len)
1428 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1429 struct sock *sk = sock->sk;
1430 struct sockaddr_ax25 sax;
1431 struct sk_buff *skb;
1432 ax25_digi dtmp, *dp;
1435 int lv, err, addr_len = msg->msg_namelen;
1437 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1443 if (sock_flag(sk, SOCK_ZAPPED)) {
1444 err = -EADDRNOTAVAIL;
1448 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1449 send_sig(SIGPIPE, current, 0);
1454 if (ax25->ax25_dev == NULL) {
1459 if (len > ax25->ax25_dev->dev->mtu) {
1465 if (usax->sax25_family != AF_AX25) {
1470 if (addr_len == sizeof(struct sockaddr_ax25))
1471 /* ax25_sendmsg(): uses obsolete socket structure */
1473 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1474 /* support for old structure may go away some time
1475 * ax25_sendmsg(): uses old (6 digipeater)
1478 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1479 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1485 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1487 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1489 /* Valid number of digipeaters ? */
1490 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1495 dtmp.ndigi = usax->sax25_ndigis;
1497 while (ct < usax->sax25_ndigis) {
1498 dtmp.repeated[ct] = 0;
1499 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1503 dtmp.lastrepeat = 0;
1507 if (sk->sk_type == SOCK_SEQPACKET &&
1508 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1512 if (usax->sax25_ndigis == 0)
1518 * FIXME: 1003.1g - if the socket is like this because
1519 * it has become closed (not started closed) and is VC
1520 * we ought to SIGPIPE, EPIPE
1522 if (sk->sk_state != TCP_ESTABLISHED) {
1526 sax.sax25_family = AF_AX25;
1527 sax.sax25_call = ax25->dest_addr;
1528 dp = ax25->digipeat;
1531 /* Build a packet */
1532 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built. Building packet.\n");
1534 /* Assume the worst case */
1535 size = len + ax25->ax25_dev->dev->hard_header_len;
1537 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1541 skb_reserve(skb, size - len);
1543 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1545 /* User data follows immediately after the AX.25 data */
1546 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1552 skb_reset_network_header(skb);
1554 /* Add the PID if one is not supplied by the user in the skb */
1556 *skb_push(skb, 1) = sk->sk_protocol;
1558 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1560 if (sk->sk_type == SOCK_SEQPACKET) {
1561 /* Connected mode sockets go via the LAPB machine */
1562 if (sk->sk_state != TCP_ESTABLISHED) {
1568 /* Shove it onto the queue and kick */
1569 ax25_output(ax25, ax25->paclen, skb);
1575 skb_push(skb, 1 + ax25_addr_size(dp));
1577 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1580 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1582 /* Build an AX.25 header */
1583 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1584 dp, AX25_COMMAND, AX25_MODULUS);
1586 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1588 skb_set_transport_header(skb, lv);
1590 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1591 skb->data, skb_transport_header(skb));
1593 *skb_transport_header(skb) = AX25_UI;
1595 /* Datagram frames go straight out of the door as UI */
1596 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1606 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1607 struct msghdr *msg, size_t size, int flags)
1609 struct sock *sk = sock->sk;
1610 struct sk_buff *skb;
1616 * This works for seqpacket too. The receiver has ordered the
1617 * queue for us! We do one quick check first though
1619 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1624 /* Now we can treat all alike */
1625 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1626 flags & MSG_DONTWAIT, &err);
1630 if (!ax25_sk(sk)->pidincl)
1631 skb_pull(skb, 1); /* Remove PID */
1633 skb_reset_transport_header(skb);
1636 if (copied > size) {
1638 msg->msg_flags |= MSG_TRUNC;
1641 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1643 if (msg->msg_namelen != 0) {
1644 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1647 const unsigned char *mac = skb_mac_header(skb);
1649 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1651 sax->sax25_family = AF_AX25;
1652 /* We set this correctly, even though we may not let the
1653 application know the digi calls further down (because it
1654 did NOT ask to know them). This could get political... **/
1655 sax->sax25_ndigis = digi.ndigi;
1656 sax->sax25_call = src;
1658 if (sax->sax25_ndigis != 0) {
1660 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1662 for (ct = 0; ct < digi.ndigi; ct++)
1663 fsa->fsa_digipeater[ct] = digi.calls[ct];
1665 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1668 skb_free_datagram(sk, skb);
1677 static int ax25_shutdown(struct socket *sk, int how)
1679 /* FIXME - generate DM and RNR states */
1683 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1685 struct sock *sk = sock->sk;
1686 void __user *argp = (void __user *)arg;
1694 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1697 res = put_user(amount, (int __user *)argp);
1702 struct sk_buff *skb;
1704 /* These two are safe on a single CPU system as only user tasks fiddle here */
1705 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1707 res = put_user(amount, (int __user *) argp);
1712 res = sock_get_timestamp(sk, argp);
1716 res = sock_get_timestampns(sk, argp);
1719 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1720 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1721 case SIOCAX25GETUID: {
1722 struct sockaddr_ax25 sax25;
1723 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1727 res = ax25_uid_ioctl(cmd, &sax25);
1731 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1733 if (!capable(CAP_NET_ADMIN)) {
1737 if (get_user(amount, (long __user *)argp)) {
1741 if (amount > AX25_NOUID_BLOCK) {
1745 ax25_uid_policy = amount;
1753 if (!capable(CAP_NET_ADMIN)) {
1757 res = ax25_rt_ioctl(cmd, argp);
1760 case SIOCAX25CTLCON:
1761 if (!capable(CAP_NET_ADMIN)) {
1765 res = ax25_ctl_ioctl(cmd, argp);
1768 case SIOCAX25GETINFO:
1769 case SIOCAX25GETINFOOLD: {
1770 ax25_cb *ax25 = ax25_sk(sk);
1771 struct ax25_info_struct ax25_info;
1773 ax25_info.t1 = ax25->t1 / HZ;
1774 ax25_info.t2 = ax25->t2 / HZ;
1775 ax25_info.t3 = ax25->t3 / HZ;
1776 ax25_info.idle = ax25->idle / (60 * HZ);
1777 ax25_info.n2 = ax25->n2;
1778 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1779 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1780 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1781 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1782 ax25_info.n2count = ax25->n2count;
1783 ax25_info.state = ax25->state;
1784 ax25_info.rcv_q = sk_wmem_alloc_get(sk);
1785 ax25_info.snd_q = sk_rmem_alloc_get(sk);
1786 ax25_info.vs = ax25->vs;
1787 ax25_info.vr = ax25->vr;
1788 ax25_info.va = ax25->va;
1789 ax25_info.vs_max = ax25->vs; /* reserved */
1790 ax25_info.paclen = ax25->paclen;
1791 ax25_info.window = ax25->window;
1793 /* old structure? */
1794 if (cmd == SIOCAX25GETINFOOLD) {
1795 static int warned = 0;
1797 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1802 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1807 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1816 case SIOCAX25ADDFWD:
1817 case SIOCAX25DELFWD: {
1818 struct ax25_fwd_struct ax25_fwd;
1819 if (!capable(CAP_NET_ADMIN)) {
1823 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1827 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1833 case SIOCGIFDSTADDR:
1834 case SIOCSIFDSTADDR:
1835 case SIOCGIFBRDADDR:
1836 case SIOCSIFBRDADDR:
1837 case SIOCGIFNETMASK:
1838 case SIOCSIFNETMASK:
1853 #ifdef CONFIG_PROC_FS
1855 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1856 __acquires(ax25_list_lock)
1858 struct ax25_cb *ax25;
1859 struct hlist_node *node;
1862 spin_lock_bh(&ax25_list_lock);
1863 ax25_for_each(ax25, node, &ax25_list) {
1871 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1875 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1876 struct ax25_cb, ax25_node);
1879 static void ax25_info_stop(struct seq_file *seq, void *v)
1880 __releases(ax25_list_lock)
1882 spin_unlock_bh(&ax25_list_lock);
1885 static int ax25_info_show(struct seq_file *seq, void *v)
1894 * 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
1897 seq_printf(seq, "%8.8lx %s %s%s ",
1899 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1900 ax2asc(buf, &ax25->source_addr),
1901 ax25->iamdigi? "*":"");
1902 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1904 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1905 seq_printf(seq, ",%s%s",
1906 ax2asc(buf, &ax25->digipeat->calls[k]),
1907 ax25->digipeat->repeated[k]? "*":"");
1910 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1912 ax25->vs, ax25->vr, ax25->va,
1913 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1914 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1915 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1916 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1917 ax25->idle / (60 * HZ),
1918 ax25->n2count, ax25->n2,
1923 if (ax25->sk != NULL) {
1924 seq_printf(seq, " %d %d %lu\n",
1925 sk_wmem_alloc_get(ax25->sk),
1926 sk_rmem_alloc_get(ax25->sk),
1927 sock_i_ino(ax25->sk));
1929 seq_puts(seq, " * * *\n");
1934 static const struct seq_operations ax25_info_seqops = {
1935 .start = ax25_info_start,
1936 .next = ax25_info_next,
1937 .stop = ax25_info_stop,
1938 .show = ax25_info_show,
1941 static int ax25_info_open(struct inode *inode, struct file *file)
1943 return seq_open(file, &ax25_info_seqops);
1946 static const struct file_operations ax25_info_fops = {
1947 .owner = THIS_MODULE,
1948 .open = ax25_info_open,
1950 .llseek = seq_lseek,
1951 .release = seq_release,
1956 static struct net_proto_family ax25_family_ops = {
1958 .create = ax25_create,
1959 .owner = THIS_MODULE,
1962 static const struct proto_ops ax25_proto_ops = {
1964 .owner = THIS_MODULE,
1965 .release = ax25_release,
1967 .connect = ax25_connect,
1968 .socketpair = sock_no_socketpair,
1969 .accept = ax25_accept,
1970 .getname = ax25_getname,
1971 .poll = datagram_poll,
1972 .ioctl = ax25_ioctl,
1973 .listen = ax25_listen,
1974 .shutdown = ax25_shutdown,
1975 .setsockopt = ax25_setsockopt,
1976 .getsockopt = ax25_getsockopt,
1977 .sendmsg = ax25_sendmsg,
1978 .recvmsg = ax25_recvmsg,
1979 .mmap = sock_no_mmap,
1980 .sendpage = sock_no_sendpage,
1984 * Called by socket.c on kernel start up
1986 static struct packet_type ax25_packet_type __read_mostly = {
1987 .type = cpu_to_be16(ETH_P_AX25),
1988 .func = ax25_kiss_rcv,
1991 static struct notifier_block ax25_dev_notifier = {
1992 .notifier_call =ax25_device_event,
1995 static int __init ax25_init(void)
1997 int rc = proto_register(&ax25_proto, 0);
2002 sock_register(&ax25_family_ops);
2003 dev_add_pack(&ax25_packet_type);
2004 register_netdevice_notifier(&ax25_dev_notifier);
2005 ax25_register_sysctl();
2007 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2008 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2009 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
2013 module_init(ax25_init);
2016 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2017 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2018 MODULE_LICENSE("GPL");
2019 MODULE_ALIAS_NETPROTO(PF_AX25);
2021 static void __exit ax25_exit(void)
2023 proc_net_remove(&init_net, "ax25_route");
2024 proc_net_remove(&init_net, "ax25");
2025 proc_net_remove(&init_net, "ax25_calls");
2030 ax25_unregister_sysctl();
2031 unregister_netdevice_notifier(&ax25_dev_notifier);
2033 dev_remove_pack(&ax25_packet_type);
2035 sock_unregister(PF_AX25);
2036 proto_unregister(&ax25_proto);
2038 module_exit(ax25_exit);