1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
5 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
6 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
7 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
8 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
9 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
10 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
11 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
13 #include <linux/capability.h>
14 #include <linux/module.h>
15 #include <linux/errno.h>
16 #include <linux/types.h>
17 #include <linux/socket.h>
19 #include <linux/kernel.h>
20 #include <linux/sched/signal.h>
21 #include <linux/timer.h>
22 #include <linux/string.h>
23 #include <linux/sockios.h>
24 #include <linux/net.h>
25 #include <linux/slab.h>
27 #include <linux/inet.h>
28 #include <linux/netdevice.h>
29 #include <linux/if_arp.h>
30 #include <linux/skbuff.h>
32 #include <linux/uaccess.h>
33 #include <linux/fcntl.h>
34 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
36 #include <linux/interrupt.h>
37 #include <linux/notifier.h>
38 #include <linux/proc_fs.h>
39 #include <linux/stat.h>
40 #include <linux/sysctl.h>
41 #include <linux/init.h>
42 #include <linux/spinlock.h>
43 #include <net/net_namespace.h>
44 #include <net/tcp_states.h>
50 HLIST_HEAD(ax25_list);
51 DEFINE_SPINLOCK(ax25_list_lock);
53 static const struct proto_ops ax25_proto_ops;
55 static void ax25_free_sock(struct sock *sk)
57 ax25_cb_put(sk_to_ax25(sk));
61 * Socket removal during an interrupt is now safe.
63 static void ax25_cb_del(ax25_cb *ax25)
65 if (!hlist_unhashed(&ax25->ax25_node)) {
66 spin_lock_bh(&ax25_list_lock);
67 hlist_del_init(&ax25->ax25_node);
68 spin_unlock_bh(&ax25_list_lock);
74 * Kill all bound sockets on a dropped device.
76 static void ax25_kill_by_device(struct net_device *dev)
81 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
84 spin_lock_bh(&ax25_list_lock);
86 ax25_for_each(s, &ax25_list) {
87 if (s->ax25_dev == ax25_dev) {
89 spin_unlock_bh(&ax25_list_lock);
90 ax25_disconnect(s, ENETUNREACH);
91 spin_lock_bh(&ax25_list_lock);
93 /* The entry could have been deleted from the
94 * list meanwhile and thus the next pointer is
95 * no longer valid. Play it safe and restart
96 * the scan. Forward progress is ensured
97 * because we set s->ax25_dev to NULL and we
98 * are never passed a NULL 'dev' argument.
103 spin_unlock_bh(&ax25_list_lock);
107 * Handle device status changes.
109 static int ax25_device_event(struct notifier_block *this, unsigned long event,
112 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
114 if (!net_eq(dev_net(dev), &init_net))
117 /* Reject non AX.25 devices */
118 if (dev->type != ARPHRD_AX25)
123 ax25_dev_device_up(dev);
126 ax25_kill_by_device(dev);
127 ax25_rt_device_down(dev);
128 ax25_dev_device_down(dev);
138 * Add a socket to the bound sockets list.
140 void ax25_cb_add(ax25_cb *ax25)
142 spin_lock_bh(&ax25_list_lock);
144 hlist_add_head(&ax25->ax25_node, &ax25_list);
145 spin_unlock_bh(&ax25_list_lock);
149 * Find a socket that wants to accept the SABM we have just
152 struct sock *ax25_find_listener(ax25_address *addr, int digi,
153 struct net_device *dev, int type)
157 spin_lock(&ax25_list_lock);
158 ax25_for_each(s, &ax25_list) {
159 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
161 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
162 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
163 /* If device is null we match any device */
164 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
166 spin_unlock(&ax25_list_lock);
171 spin_unlock(&ax25_list_lock);
177 * Find an AX.25 socket given both ends.
179 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
182 struct sock *sk = NULL;
185 spin_lock(&ax25_list_lock);
186 ax25_for_each(s, &ax25_list) {
187 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
188 !ax25cmp(&s->dest_addr, dest_addr) &&
189 s->sk->sk_type == type) {
196 spin_unlock(&ax25_list_lock);
202 * Find an AX.25 control block given both ends. It will only pick up
203 * floating AX.25 control blocks or non Raw socket bound control blocks.
205 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
206 ax25_digi *digi, struct net_device *dev)
210 spin_lock_bh(&ax25_list_lock);
211 ax25_for_each(s, &ax25_list) {
212 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
214 if (s->ax25_dev == NULL)
216 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
217 if (digi != NULL && digi->ndigi != 0) {
218 if (s->digipeat == NULL)
220 if (ax25digicmp(s->digipeat, digi) != 0)
223 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
227 spin_unlock_bh(&ax25_list_lock);
232 spin_unlock_bh(&ax25_list_lock);
237 EXPORT_SYMBOL(ax25_find_cb);
239 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
242 struct sk_buff *copy;
244 spin_lock(&ax25_list_lock);
245 ax25_for_each(s, &ax25_list) {
246 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
247 s->sk->sk_type == SOCK_RAW &&
248 s->sk->sk_protocol == proto &&
249 s->ax25_dev->dev == skb->dev &&
250 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
251 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
253 if (sock_queue_rcv_skb(s->sk, copy) != 0)
257 spin_unlock(&ax25_list_lock);
263 void ax25_destroy_socket(ax25_cb *);
266 * Handler for deferred kills.
268 static void ax25_destroy_timer(struct timer_list *t)
270 ax25_cb *ax25 = from_timer(ax25, t, dtimer);
277 ax25_destroy_socket(ax25);
283 * This is called from user mode and the timers. Thus it protects itself
284 * against interrupt users but doesn't worry about being called during
285 * work. Once it is removed from the queue no interrupt or bottom half
286 * will touch it and we are (fairly 8-) ) safe.
288 void ax25_destroy_socket(ax25_cb *ax25)
294 ax25_stop_heartbeat(ax25);
295 ax25_stop_t1timer(ax25);
296 ax25_stop_t2timer(ax25);
297 ax25_stop_t3timer(ax25);
298 ax25_stop_idletimer(ax25);
300 ax25_clear_queues(ax25); /* Flush the queues */
302 if (ax25->sk != NULL) {
303 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
304 if (skb->sk != ax25->sk) {
305 /* A pending connection */
306 ax25_cb *sax25 = sk_to_ax25(skb->sk);
308 /* Queue the unaccepted socket for death */
309 sock_orphan(skb->sk);
311 /* 9A4GL: hack to release unaccepted sockets */
312 skb->sk->sk_state = TCP_LISTEN;
314 ax25_start_heartbeat(sax25);
315 sax25->state = AX25_STATE_0;
320 skb_queue_purge(&ax25->sk->sk_write_queue);
323 if (ax25->sk != NULL) {
324 if (sk_has_allocations(ax25->sk)) {
325 /* Defer: outstanding buffers */
326 timer_setup(&ax25->dtimer, ax25_destroy_timer, 0);
327 ax25->dtimer.expires = jiffies + 2 * HZ;
328 add_timer(&ax25->dtimer);
330 struct sock *sk=ax25->sk;
340 * dl1bke 960311: set parameters for existing AX.25 connections,
341 * includes a KILL command to abort any connection.
342 * VERY useful for debugging ;-)
344 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
346 struct ax25_ctl_struct ax25_ctl;
353 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
356 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
359 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
362 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
365 digi.ndigi = ax25_ctl.digi_count;
366 for (k = 0; k < digi.ndigi; k++)
367 digi.calls[k] = ax25_ctl.digi_addr[k];
369 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
372 switch (ax25_ctl.cmd) {
374 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
375 #ifdef CONFIG_AX25_DAMA_SLAVE
376 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
379 ax25_disconnect(ax25, ENETRESET);
383 if (ax25->modulus == AX25_MODULUS) {
384 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
387 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
390 ax25->window = ax25_ctl.arg;
394 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
396 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
397 ax25->t1 = ax25_ctl.arg * HZ;
401 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
403 ax25->t2 = ax25_ctl.arg * HZ;
407 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
410 ax25->n2 = ax25_ctl.arg;
414 if (ax25_ctl.arg > ULONG_MAX / HZ)
416 ax25->t3 = ax25_ctl.arg * HZ;
420 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
423 ax25->idle = ax25_ctl.arg * 60 * HZ;
427 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
429 ax25->paclen = ax25_ctl.arg;
445 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
447 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
448 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
449 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
450 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
451 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
452 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
453 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
454 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
456 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
457 ax25->modulus = AX25_EMODULUS;
458 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
460 ax25->modulus = AX25_MODULUS;
461 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
466 * Fill in a created AX.25 created control block with the default
467 * values for a particular device.
469 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
471 ax25->ax25_dev = ax25_dev;
473 if (ax25->ax25_dev != NULL) {
474 ax25_fillin_cb_from_dev(ax25, ax25_dev);
479 * No device, use kernel / AX.25 spec default values
481 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
482 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
483 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
484 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
485 ax25->n2 = AX25_DEF_N2;
486 ax25->paclen = AX25_DEF_PACLEN;
487 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
488 ax25->backoff = AX25_DEF_BACKOFF;
490 if (AX25_DEF_AXDEFMODE) {
491 ax25->modulus = AX25_EMODULUS;
492 ax25->window = AX25_DEF_EWINDOW;
494 ax25->modulus = AX25_MODULUS;
495 ax25->window = AX25_DEF_WINDOW;
500 * Create an empty AX.25 control block.
502 ax25_cb *ax25_create_cb(void)
506 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
509 refcount_set(&ax25->refcount, 1);
511 skb_queue_head_init(&ax25->write_queue);
512 skb_queue_head_init(&ax25->frag_queue);
513 skb_queue_head_init(&ax25->ack_queue);
514 skb_queue_head_init(&ax25->reseq_queue);
516 ax25_setup_timers(ax25);
518 ax25_fillin_cb(ax25, NULL);
520 ax25->state = AX25_STATE_0;
526 * Handling for system calls applied via the various interfaces to an
530 static int ax25_setsockopt(struct socket *sock, int level, int optname,
531 char __user *optval, unsigned int optlen)
533 struct sock *sk = sock->sk;
535 struct net_device *dev;
536 char devname[IFNAMSIZ];
540 if (level != SOL_AX25)
543 if (optlen < sizeof(unsigned int))
546 if (get_user(opt, (unsigned int __user *)optval))
550 ax25 = sk_to_ax25(sk);
554 if (ax25->modulus == AX25_MODULUS) {
555 if (opt < 1 || opt > 7) {
560 if (opt < 1 || opt > 63) {
569 if (opt < 1 || opt > ULONG_MAX / HZ) {
573 ax25->rtt = (opt * HZ) >> 1;
578 if (opt < 1 || opt > ULONG_MAX / HZ) {
586 if (opt < 1 || opt > 31) {
594 if (opt < 1 || opt > ULONG_MAX / HZ) {
602 if (opt > ULONG_MAX / (60 * HZ)) {
606 ax25->idle = opt * 60 * HZ;
618 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
622 ax25->pidincl = opt ? 1 : 0;
626 ax25->iamdigi = opt ? 1 : 0;
630 if (opt < 16 || opt > 65535) {
637 case SO_BINDTODEVICE:
638 if (optlen > IFNAMSIZ - 1)
639 optlen = IFNAMSIZ - 1;
641 memset(devname, 0, sizeof(devname));
643 if (copy_from_user(devname, optval, optlen)) {
648 if (sk->sk_type == SOCK_SEQPACKET &&
649 (sock->state != SS_UNCONNECTED ||
650 sk->sk_state == TCP_LISTEN)) {
651 res = -EADDRNOTAVAIL;
656 dev = __dev_get_by_name(&init_net, devname);
663 ax25->ax25_dev = ax25_dev_ax25dev(dev);
664 if (!ax25->ax25_dev) {
669 ax25_fillin_cb(ax25, ax25->ax25_dev);
681 static int ax25_getsockopt(struct socket *sock, int level, int optname,
682 char __user *optval, int __user *optlen)
684 struct sock *sk = sock->sk;
686 struct ax25_dev *ax25_dev;
687 char devname[IFNAMSIZ];
692 if (level != SOL_AX25)
695 if (get_user(maxlen, optlen))
701 valptr = (void *) &val;
702 length = min_t(unsigned int, maxlen, sizeof(int));
705 ax25 = sk_to_ax25(sk);
729 val = ax25->idle / (60 * HZ);
737 val = (ax25->modulus == AX25_EMODULUS);
752 case SO_BINDTODEVICE:
753 ax25_dev = ax25->ax25_dev;
755 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
756 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
757 length = strlen(devname) + 1;
763 valptr = (void *) devname;
772 if (put_user(length, optlen))
775 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
778 static int ax25_listen(struct socket *sock, int backlog)
780 struct sock *sk = sock->sk;
784 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
785 sk->sk_max_ack_backlog = backlog;
786 sk->sk_state = TCP_LISTEN;
798 * XXX: when creating ax25_sock we should update the .obj_size setting
801 static struct proto ax25_proto = {
803 .owner = THIS_MODULE,
804 .obj_size = sizeof(struct ax25_sock),
807 static int ax25_create(struct net *net, struct socket *sock, int protocol,
813 if (protocol < 0 || protocol > U8_MAX)
816 if (!net_eq(net, &init_net))
817 return -EAFNOSUPPORT;
819 switch (sock->type) {
821 if (protocol == 0 || protocol == PF_AX25)
822 protocol = AX25_P_TEXT;
828 case PF_AX25: /* For CLX */
829 protocol = AX25_P_TEXT;
842 return -ESOCKTNOSUPPORT;
843 #ifdef CONFIG_NETROM_MODULE
845 if (ax25_protocol_is_registered(AX25_P_NETROM))
846 return -ESOCKTNOSUPPORT;
849 #ifdef CONFIG_ROSE_MODULE
851 if (ax25_protocol_is_registered(AX25_P_ROSE))
852 return -ESOCKTNOSUPPORT;
860 if (!capable(CAP_NET_RAW))
864 return -ESOCKTNOSUPPORT;
867 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
871 ax25 = ax25_sk(sk)->cb = ax25_create_cb();
877 sock_init_data(sock, sk);
879 sk->sk_destruct = ax25_free_sock;
880 sock->ops = &ax25_proto_ops;
881 sk->sk_protocol = protocol;
888 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
891 ax25_cb *ax25, *oax25;
893 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
897 if ((ax25 = ax25_create_cb()) == NULL) {
902 switch (osk->sk_type) {
913 sock_init_data(NULL, sk);
915 sk->sk_type = osk->sk_type;
916 sk->sk_priority = osk->sk_priority;
917 sk->sk_protocol = osk->sk_protocol;
918 sk->sk_rcvbuf = osk->sk_rcvbuf;
919 sk->sk_sndbuf = osk->sk_sndbuf;
920 sk->sk_state = TCP_ESTABLISHED;
921 sock_copy_flags(sk, osk);
923 oax25 = sk_to_ax25(osk);
925 ax25->modulus = oax25->modulus;
926 ax25->backoff = oax25->backoff;
927 ax25->pidincl = oax25->pidincl;
928 ax25->iamdigi = oax25->iamdigi;
929 ax25->rtt = oax25->rtt;
930 ax25->t1 = oax25->t1;
931 ax25->t2 = oax25->t2;
932 ax25->t3 = oax25->t3;
933 ax25->n2 = oax25->n2;
934 ax25->idle = oax25->idle;
935 ax25->paclen = oax25->paclen;
936 ax25->window = oax25->window;
938 ax25->ax25_dev = ax25_dev;
939 ax25->source_addr = oax25->source_addr;
941 if (oax25->digipeat != NULL) {
942 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
944 if (ax25->digipeat == NULL) {
951 ax25_sk(sk)->cb = ax25;
952 sk->sk_destruct = ax25_free_sock;
958 static int ax25_release(struct socket *sock)
960 struct sock *sk = sock->sk;
969 ax25 = sk_to_ax25(sk);
971 if (sk->sk_type == SOCK_SEQPACKET) {
972 switch (ax25->state) {
975 ax25_disconnect(ax25, 0);
977 ax25_destroy_socket(ax25);
982 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
984 ax25_disconnect(ax25, 0);
986 if (!sock_flag(ax25->sk, SOCK_DESTROY))
987 ax25_destroy_socket(ax25);
992 ax25_clear_queues(ax25);
995 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
996 case AX25_PROTO_STD_SIMPLEX:
997 case AX25_PROTO_STD_DUPLEX:
998 ax25_send_control(ax25,
1002 ax25_stop_t2timer(ax25);
1003 ax25_stop_t3timer(ax25);
1004 ax25_stop_idletimer(ax25);
1006 #ifdef CONFIG_AX25_DAMA_SLAVE
1007 case AX25_PROTO_DAMA_SLAVE:
1008 ax25_stop_t3timer(ax25);
1009 ax25_stop_idletimer(ax25);
1013 ax25_calculate_t1(ax25);
1014 ax25_start_t1timer(ax25);
1015 ax25->state = AX25_STATE_2;
1016 sk->sk_state = TCP_CLOSE;
1017 sk->sk_shutdown |= SEND_SHUTDOWN;
1018 sk->sk_state_change(sk);
1019 sock_set_flag(sk, SOCK_DESTROY);
1026 sk->sk_state = TCP_CLOSE;
1027 sk->sk_shutdown |= SEND_SHUTDOWN;
1028 sk->sk_state_change(sk);
1029 ax25_destroy_socket(ax25);
1040 * We support a funny extension here so you can (as root) give any callsign
1041 * digipeated via a local address as source. This hack is obsolete now
1042 * that we've implemented support for SO_BINDTODEVICE. It is however small
1043 * and trivially backward compatible.
1045 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1047 struct sock *sk = sock->sk;
1048 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1049 ax25_dev *ax25_dev = NULL;
1050 ax25_uid_assoc *user;
1055 if (addr_len != sizeof(struct sockaddr_ax25) &&
1056 addr_len != sizeof(struct full_sockaddr_ax25))
1057 /* support for old structure may go away some time
1058 * ax25_bind(): uses old (6 digipeater) socket structure.
1060 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1061 (addr_len > sizeof(struct full_sockaddr_ax25)))
1064 if (addr->fsa_ax25.sax25_family != AF_AX25)
1067 user = ax25_findbyuid(current_euid());
1072 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1075 call = addr->fsa_ax25.sax25_call;
1080 ax25 = sk_to_ax25(sk);
1081 if (!sock_flag(sk, SOCK_ZAPPED)) {
1086 ax25->source_addr = call;
1089 * User already set interface with SO_BINDTODEVICE
1091 if (ax25->ax25_dev != NULL)
1094 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1095 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1096 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1097 err = -EADDRNOTAVAIL;
1101 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1102 err = -EADDRNOTAVAIL;
1107 if (ax25_dev != NULL)
1108 ax25_fillin_cb(ax25, ax25_dev);
1112 sock_reset_flag(sk, SOCK_ZAPPED);
1121 * FIXME: nonblock behaviour looks like it may have a bug.
1123 static int __must_check ax25_connect(struct socket *sock,
1124 struct sockaddr *uaddr, int addr_len, int flags)
1126 struct sock *sk = sock->sk;
1127 ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1128 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1129 ax25_digi *digi = NULL;
1130 int ct = 0, err = 0;
1133 * some sanity checks. code further down depends on this
1136 if (addr_len == sizeof(struct sockaddr_ax25))
1137 /* support for this will go away in early 2.5.x
1138 * ax25_connect(): uses obsolete socket structure
1141 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1142 /* support for old structure may go away some time
1143 * ax25_connect(): uses old (6 digipeater) socket structure.
1145 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1146 (addr_len > sizeof(struct full_sockaddr_ax25)))
1150 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1155 /* deal with restarts */
1156 if (sock->state == SS_CONNECTING) {
1157 switch (sk->sk_state) {
1158 case TCP_SYN_SENT: /* still trying */
1162 case TCP_ESTABLISHED: /* connection established */
1163 sock->state = SS_CONNECTED;
1166 case TCP_CLOSE: /* connection refused */
1167 sock->state = SS_UNCONNECTED;
1168 err = -ECONNREFUSED;
1173 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1174 err = -EISCONN; /* No reconnect on a seqpacket socket */
1178 sk->sk_state = TCP_CLOSE;
1179 sock->state = SS_UNCONNECTED;
1181 kfree(ax25->digipeat);
1182 ax25->digipeat = NULL;
1185 * Handle digi-peaters to be used.
1187 if (addr_len > sizeof(struct sockaddr_ax25) &&
1188 fsa->fsa_ax25.sax25_ndigis != 0) {
1189 /* Valid number of digipeaters ? */
1190 if (fsa->fsa_ax25.sax25_ndigis < 1 ||
1191 fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS ||
1192 addr_len < sizeof(struct sockaddr_ax25) +
1193 sizeof(ax25_address) * fsa->fsa_ax25.sax25_ndigis) {
1198 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1203 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1204 digi->lastrepeat = -1;
1206 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1207 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1208 AX25_HBIT) && ax25->iamdigi) {
1209 digi->repeated[ct] = 1;
1210 digi->lastrepeat = ct;
1212 digi->repeated[ct] = 0;
1214 digi->calls[ct] = fsa->fsa_digipeater[ct];
1220 * Must bind first - autobinding in this may or may not work. If
1221 * the socket is already bound, check to see if the device has
1222 * been filled in, error if it hasn't.
1224 if (sock_flag(sk, SOCK_ZAPPED)) {
1225 /* check if we can remove this feature. It is broken. */
1226 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1228 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1233 ax25_fillin_cb(ax25, ax25->ax25_dev);
1236 if (ax25->ax25_dev == NULL) {
1238 err = -EHOSTUNREACH;
1243 if (sk->sk_type == SOCK_SEQPACKET &&
1244 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1245 ax25->ax25_dev->dev))) {
1247 err = -EADDRINUSE; /* Already such a connection */
1252 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1253 ax25->digipeat = digi;
1255 /* First the easy one */
1256 if (sk->sk_type != SOCK_SEQPACKET) {
1257 sock->state = SS_CONNECTED;
1258 sk->sk_state = TCP_ESTABLISHED;
1262 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1263 sock->state = SS_CONNECTING;
1264 sk->sk_state = TCP_SYN_SENT;
1266 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1267 case AX25_PROTO_STD_SIMPLEX:
1268 case AX25_PROTO_STD_DUPLEX:
1269 ax25_std_establish_data_link(ax25);
1272 #ifdef CONFIG_AX25_DAMA_SLAVE
1273 case AX25_PROTO_DAMA_SLAVE:
1274 ax25->modulus = AX25_MODULUS;
1275 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1276 if (ax25->ax25_dev->dama.slave)
1277 ax25_ds_establish_data_link(ax25);
1279 ax25_std_establish_data_link(ax25);
1284 ax25->state = AX25_STATE_1;
1286 ax25_start_heartbeat(ax25);
1289 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1294 if (sk->sk_state == TCP_SYN_SENT) {
1298 prepare_to_wait(sk_sleep(sk), &wait,
1299 TASK_INTERRUPTIBLE);
1300 if (sk->sk_state != TCP_SYN_SENT)
1302 if (!signal_pending(current)) {
1311 finish_wait(sk_sleep(sk), &wait);
1317 if (sk->sk_state != TCP_ESTABLISHED) {
1318 /* Not in ABM, not in WAIT_UA -> failed */
1319 sock->state = SS_UNCONNECTED;
1320 err = sock_error(sk); /* Always set at this point */
1324 sock->state = SS_CONNECTED;
1333 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags,
1336 struct sk_buff *skb;
1342 if (sock->state != SS_UNCONNECTED)
1345 if ((sk = sock->sk) == NULL)
1349 if (sk->sk_type != SOCK_SEQPACKET) {
1354 if (sk->sk_state != TCP_LISTEN) {
1360 * The read queue this time is holding sockets ready to use
1361 * hooked into the SABM we saved
1364 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1365 skb = skb_dequeue(&sk->sk_receive_queue);
1369 if (flags & O_NONBLOCK) {
1373 if (!signal_pending(current)) {
1382 finish_wait(sk_sleep(sk), &wait);
1388 sock_graft(newsk, newsock);
1390 /* Now attach up the new socket */
1392 sk_acceptq_removed(sk);
1393 newsock->state = SS_CONNECTED;
1401 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1404 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1405 struct sock *sk = sock->sk;
1406 unsigned char ndigi, i;
1410 memset(fsa, 0, sizeof(*fsa));
1412 ax25 = sk_to_ax25(sk);
1415 if (sk->sk_state != TCP_ESTABLISHED) {
1420 fsa->fsa_ax25.sax25_family = AF_AX25;
1421 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1423 if (ax25->digipeat != NULL) {
1424 ndigi = ax25->digipeat->ndigi;
1425 fsa->fsa_ax25.sax25_ndigis = ndigi;
1426 for (i = 0; i < ndigi; i++)
1427 fsa->fsa_digipeater[i] =
1428 ax25->digipeat->calls[i];
1431 fsa->fsa_ax25.sax25_family = AF_AX25;
1432 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1433 fsa->fsa_ax25.sax25_ndigis = 1;
1434 if (ax25->ax25_dev != NULL) {
1435 memcpy(&fsa->fsa_digipeater[0],
1436 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1438 fsa->fsa_digipeater[0] = null_ax25_address;
1441 err = sizeof (struct full_sockaddr_ax25);
1449 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1451 DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1452 struct sock *sk = sock->sk;
1453 struct sockaddr_ax25 sax;
1454 struct sk_buff *skb;
1455 ax25_digi dtmp, *dp;
1458 int lv, err, addr_len = msg->msg_namelen;
1460 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1464 ax25 = sk_to_ax25(sk);
1466 if (sock_flag(sk, SOCK_ZAPPED)) {
1467 err = -EADDRNOTAVAIL;
1471 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1472 send_sig(SIGPIPE, current, 0);
1477 if (ax25->ax25_dev == NULL) {
1482 if (len > ax25->ax25_dev->dev->mtu) {
1488 if (usax->sax25_family != AF_AX25) {
1493 if (addr_len == sizeof(struct sockaddr_ax25))
1494 /* ax25_sendmsg(): uses obsolete socket structure */
1496 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1497 /* support for old structure may go away some time
1498 * ax25_sendmsg(): uses old (6 digipeater)
1501 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1502 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1508 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1510 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1512 /* Valid number of digipeaters ? */
1513 if (usax->sax25_ndigis < 1 ||
1514 usax->sax25_ndigis > AX25_MAX_DIGIS ||
1515 addr_len < sizeof(struct sockaddr_ax25) +
1516 sizeof(ax25_address) * usax->sax25_ndigis) {
1521 dtmp.ndigi = usax->sax25_ndigis;
1523 while (ct < usax->sax25_ndigis) {
1524 dtmp.repeated[ct] = 0;
1525 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1529 dtmp.lastrepeat = 0;
1533 if (sk->sk_type == SOCK_SEQPACKET &&
1534 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1538 if (usax->sax25_ndigis == 0)
1544 * FIXME: 1003.1g - if the socket is like this because
1545 * it has become closed (not started closed) and is VC
1546 * we ought to SIGPIPE, EPIPE
1548 if (sk->sk_state != TCP_ESTABLISHED) {
1552 sax.sax25_family = AF_AX25;
1553 sax.sax25_call = ax25->dest_addr;
1554 dp = ax25->digipeat;
1557 /* Build a packet */
1558 /* Assume the worst case */
1559 size = len + ax25->ax25_dev->dev->hard_header_len;
1561 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1565 skb_reserve(skb, size - len);
1567 /* User data follows immediately after the AX.25 data */
1568 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1574 skb_reset_network_header(skb);
1576 /* Add the PID if one is not supplied by the user in the skb */
1578 *(u8 *)skb_push(skb, 1) = sk->sk_protocol;
1580 if (sk->sk_type == SOCK_SEQPACKET) {
1581 /* Connected mode sockets go via the LAPB machine */
1582 if (sk->sk_state != TCP_ESTABLISHED) {
1588 /* Shove it onto the queue and kick */
1589 ax25_output(ax25, ax25->paclen, skb);
1595 skb_push(skb, 1 + ax25_addr_size(dp));
1597 /* Building AX.25 Header */
1599 /* Build an AX.25 header */
1600 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1601 dp, AX25_COMMAND, AX25_MODULUS);
1603 skb_set_transport_header(skb, lv);
1605 *skb_transport_header(skb) = AX25_UI;
1607 /* Datagram frames go straight out of the door as UI */
1608 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1618 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1621 struct sock *sk = sock->sk;
1622 struct sk_buff *skb;
1628 * This works for seqpacket too. The receiver has ordered the
1629 * queue for us! We do one quick check first though
1631 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1636 /* Now we can treat all alike */
1637 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1638 flags & MSG_DONTWAIT, &err);
1642 if (!sk_to_ax25(sk)->pidincl)
1643 skb_pull(skb, 1); /* Remove PID */
1645 skb_reset_transport_header(skb);
1648 if (copied > size) {
1650 msg->msg_flags |= MSG_TRUNC;
1653 skb_copy_datagram_msg(skb, 0, msg, copied);
1655 if (msg->msg_name) {
1658 const unsigned char *mac = skb_mac_header(skb);
1659 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1661 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1662 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1664 sax->sax25_family = AF_AX25;
1665 /* We set this correctly, even though we may not let the
1666 application know the digi calls further down (because it
1667 did NOT ask to know them). This could get political... **/
1668 sax->sax25_ndigis = digi.ndigi;
1669 sax->sax25_call = src;
1671 if (sax->sax25_ndigis != 0) {
1673 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1675 for (ct = 0; ct < digi.ndigi; ct++)
1676 fsa->fsa_digipeater[ct] = digi.calls[ct];
1678 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1681 skb_free_datagram(sk, skb);
1690 static int ax25_shutdown(struct socket *sk, int how)
1692 /* FIXME - generate DM and RNR states */
1696 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1698 struct sock *sk = sock->sk;
1699 void __user *argp = (void __user *)arg;
1707 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1710 res = put_user(amount, (int __user *)argp);
1715 struct sk_buff *skb;
1717 /* These two are safe on a single CPU system as only user tasks fiddle here */
1718 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1720 res = put_user(amount, (int __user *) argp);
1724 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1725 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1726 case SIOCAX25GETUID: {
1727 struct sockaddr_ax25 sax25;
1728 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1732 res = ax25_uid_ioctl(cmd, &sax25);
1736 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1738 if (!capable(CAP_NET_ADMIN)) {
1742 if (get_user(amount, (long __user *)argp)) {
1746 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1750 ax25_uid_policy = amount;
1758 if (!capable(CAP_NET_ADMIN)) {
1762 res = ax25_rt_ioctl(cmd, argp);
1765 case SIOCAX25CTLCON:
1766 if (!capable(CAP_NET_ADMIN)) {
1770 res = ax25_ctl_ioctl(cmd, argp);
1773 case SIOCAX25GETINFO:
1774 case SIOCAX25GETINFOOLD: {
1775 ax25_cb *ax25 = sk_to_ax25(sk);
1776 struct ax25_info_struct ax25_info;
1778 ax25_info.t1 = ax25->t1 / HZ;
1779 ax25_info.t2 = ax25->t2 / HZ;
1780 ax25_info.t3 = ax25->t3 / HZ;
1781 ax25_info.idle = ax25->idle / (60 * HZ);
1782 ax25_info.n2 = ax25->n2;
1783 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1784 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1785 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1786 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1787 ax25_info.n2count = ax25->n2count;
1788 ax25_info.state = ax25->state;
1789 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1790 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1791 ax25_info.vs = ax25->vs;
1792 ax25_info.vr = ax25->vr;
1793 ax25_info.va = ax25->va;
1794 ax25_info.vs_max = ax25->vs; /* reserved */
1795 ax25_info.paclen = ax25->paclen;
1796 ax25_info.window = ax25->window;
1798 /* old structure? */
1799 if (cmd == SIOCAX25GETINFOOLD) {
1800 static int warned = 0;
1802 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1807 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1812 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1821 case SIOCAX25ADDFWD:
1822 case SIOCAX25DELFWD: {
1823 struct ax25_fwd_struct ax25_fwd;
1824 if (!capable(CAP_NET_ADMIN)) {
1828 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1832 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1838 case SIOCGIFDSTADDR:
1839 case SIOCSIFDSTADDR:
1840 case SIOCGIFBRDADDR:
1841 case SIOCSIFBRDADDR:
1842 case SIOCGIFNETMASK:
1843 case SIOCSIFNETMASK:
1858 #ifdef CONFIG_PROC_FS
1860 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1861 __acquires(ax25_list_lock)
1863 spin_lock_bh(&ax25_list_lock);
1864 return seq_hlist_start(&ax25_list, *pos);
1867 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1869 return seq_hlist_next(v, &ax25_list, pos);
1872 static void ax25_info_stop(struct seq_file *seq, void *v)
1873 __releases(ax25_list_lock)
1875 spin_unlock_bh(&ax25_list_lock);
1878 static int ax25_info_show(struct seq_file *seq, void *v)
1880 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1887 * 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 seq_printf(seq, "%p %s %s%s ",
1892 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1893 ax2asc(buf, &ax25->source_addr),
1894 ax25->iamdigi? "*":"");
1895 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1897 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1898 seq_printf(seq, ",%s%s",
1899 ax2asc(buf, &ax25->digipeat->calls[k]),
1900 ax25->digipeat->repeated[k]? "*":"");
1903 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1905 ax25->vs, ax25->vr, ax25->va,
1906 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1907 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1908 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1909 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1910 ax25->idle / (60 * HZ),
1911 ax25->n2count, ax25->n2,
1916 if (ax25->sk != NULL) {
1917 seq_printf(seq, " %d %d %lu\n",
1918 sk_wmem_alloc_get(ax25->sk),
1919 sk_rmem_alloc_get(ax25->sk),
1920 sock_i_ino(ax25->sk));
1922 seq_puts(seq, " * * *\n");
1927 static const struct seq_operations ax25_info_seqops = {
1928 .start = ax25_info_start,
1929 .next = ax25_info_next,
1930 .stop = ax25_info_stop,
1931 .show = ax25_info_show,
1935 static const struct net_proto_family ax25_family_ops = {
1937 .create = ax25_create,
1938 .owner = THIS_MODULE,
1941 static const struct proto_ops ax25_proto_ops = {
1943 .owner = THIS_MODULE,
1944 .release = ax25_release,
1946 .connect = ax25_connect,
1947 .socketpair = sock_no_socketpair,
1948 .accept = ax25_accept,
1949 .getname = ax25_getname,
1950 .poll = datagram_poll,
1951 .ioctl = ax25_ioctl,
1952 .gettstamp = sock_gettstamp,
1953 .listen = ax25_listen,
1954 .shutdown = ax25_shutdown,
1955 .setsockopt = ax25_setsockopt,
1956 .getsockopt = ax25_getsockopt,
1957 .sendmsg = ax25_sendmsg,
1958 .recvmsg = ax25_recvmsg,
1959 .mmap = sock_no_mmap,
1960 .sendpage = sock_no_sendpage,
1964 * Called by socket.c on kernel start up
1966 static struct packet_type ax25_packet_type __read_mostly = {
1967 .type = cpu_to_be16(ETH_P_AX25),
1968 .func = ax25_kiss_rcv,
1971 static struct notifier_block ax25_dev_notifier = {
1972 .notifier_call = ax25_device_event,
1975 static int __init ax25_init(void)
1977 int rc = proto_register(&ax25_proto, 0);
1982 sock_register(&ax25_family_ops);
1983 dev_add_pack(&ax25_packet_type);
1984 register_netdevice_notifier(&ax25_dev_notifier);
1986 proc_create_seq("ax25_route", 0444, init_net.proc_net, &ax25_rt_seqops);
1987 proc_create_seq("ax25", 0444, init_net.proc_net, &ax25_info_seqops);
1988 proc_create_seq("ax25_calls", 0444, init_net.proc_net,
1993 module_init(ax25_init);
1996 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1997 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
1998 MODULE_LICENSE("GPL");
1999 MODULE_ALIAS_NETPROTO(PF_AX25);
2001 static void __exit ax25_exit(void)
2003 remove_proc_entry("ax25_route", init_net.proc_net);
2004 remove_proc_entry("ax25", init_net.proc_net);
2005 remove_proc_entry("ax25_calls", init_net.proc_net);
2007 unregister_netdevice_notifier(&ax25_dev_notifier);
2009 dev_remove_pack(&ax25_packet_type);
2011 sock_unregister(PF_AX25);
2012 proto_unregister(&ax25_proto);
2018 module_exit(ax25_exit);