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;
363 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
366 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
369 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
372 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
375 digi.ndigi = ax25_ctl.digi_count;
376 for (k = 0; k < digi.ndigi; k++)
377 digi.calls[k] = ax25_ctl.digi_addr[k];
379 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
382 switch (ax25_ctl.cmd) {
384 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
385 #ifdef CONFIG_AX25_DAMA_SLAVE
386 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
389 ax25_disconnect(ax25, ENETRESET);
393 if (ax25->modulus == AX25_MODULUS) {
394 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
397 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
400 ax25->window = ax25_ctl.arg;
404 if (ax25_ctl.arg < 1)
406 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
407 ax25->t1 = ax25_ctl.arg * HZ;
411 if (ax25_ctl.arg < 1)
413 ax25->t2 = ax25_ctl.arg * HZ;
417 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
420 ax25->n2 = ax25_ctl.arg;
424 ax25->t3 = ax25_ctl.arg * HZ;
428 ax25->idle = ax25_ctl.arg * 60 * HZ;
432 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
434 ax25->paclen = ax25_ctl.arg;
450 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
452 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
453 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
454 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
455 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
456 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
457 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
458 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
459 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
461 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
462 ax25->modulus = AX25_EMODULUS;
463 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
465 ax25->modulus = AX25_MODULUS;
466 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
471 * Fill in a created AX.25 created control block with the default
472 * values for a particular device.
474 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
476 ax25->ax25_dev = ax25_dev;
478 if (ax25->ax25_dev != NULL) {
479 ax25_fillin_cb_from_dev(ax25, ax25_dev);
484 * No device, use kernel / AX.25 spec default values
486 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
487 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
488 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
489 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
490 ax25->n2 = AX25_DEF_N2;
491 ax25->paclen = AX25_DEF_PACLEN;
492 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
493 ax25->backoff = AX25_DEF_BACKOFF;
495 if (AX25_DEF_AXDEFMODE) {
496 ax25->modulus = AX25_EMODULUS;
497 ax25->window = AX25_DEF_EWINDOW;
499 ax25->modulus = AX25_MODULUS;
500 ax25->window = AX25_DEF_WINDOW;
505 * Create an empty AX.25 control block.
507 ax25_cb *ax25_create_cb(void)
511 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
514 atomic_set(&ax25->refcount, 1);
516 skb_queue_head_init(&ax25->write_queue);
517 skb_queue_head_init(&ax25->frag_queue);
518 skb_queue_head_init(&ax25->ack_queue);
519 skb_queue_head_init(&ax25->reseq_queue);
521 ax25_setup_timers(ax25);
523 ax25_fillin_cb(ax25, NULL);
525 ax25->state = AX25_STATE_0;
531 * Handling for system calls applied via the various interfaces to an
535 static int ax25_setsockopt(struct socket *sock, int level, int optname,
536 char __user *optval, unsigned int optlen)
538 struct sock *sk = sock->sk;
540 struct net_device *dev;
541 char devname[IFNAMSIZ];
544 if (level != SOL_AX25)
547 if (optlen < sizeof(int))
550 if (get_user(opt, (int __user *)optval))
558 if (ax25->modulus == AX25_MODULUS) {
559 if (opt < 1 || opt > 7) {
564 if (opt < 1 || opt > 63) {
577 ax25->rtt = (opt * HZ) >> 1;
590 if (opt < 1 || opt > 31) {
610 ax25->idle = opt * 60 * HZ;
614 if (opt < 0 || opt > 2) {
622 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
626 ax25->pidincl = opt ? 1 : 0;
630 ax25->iamdigi = opt ? 1 : 0;
634 if (opt < 16 || opt > 65535) {
641 case SO_BINDTODEVICE:
642 if (optlen > IFNAMSIZ)
645 if (copy_from_user(devname, optval, optlen)) {
650 if (sk->sk_type == SOCK_SEQPACKET &&
651 (sock->state != SS_UNCONNECTED ||
652 sk->sk_state == TCP_LISTEN)) {
653 res = -EADDRNOTAVAIL;
657 dev = dev_get_by_name(&init_net, devname);
663 ax25->ax25_dev = ax25_dev_ax25dev(dev);
664 ax25_fillin_cb(ax25, ax25->ax25_dev);
676 static int ax25_getsockopt(struct socket *sock, int level, int optname,
677 char __user *optval, int __user *optlen)
679 struct sock *sk = sock->sk;
681 struct ax25_dev *ax25_dev;
682 char devname[IFNAMSIZ];
687 if (level != SOL_AX25)
690 if (get_user(maxlen, optlen))
696 valptr = (void *) &val;
697 length = min_t(unsigned int, maxlen, sizeof(int));
724 val = ax25->idle / (60 * HZ);
732 val = (ax25->modulus == AX25_EMODULUS);
747 case SO_BINDTODEVICE:
748 ax25_dev = ax25->ax25_dev;
750 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
751 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
752 length = strlen(devname) + 1;
758 valptr = (void *) devname;
767 if (put_user(length, optlen))
770 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
773 static int ax25_listen(struct socket *sock, int backlog)
775 struct sock *sk = sock->sk;
779 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
780 sk->sk_max_ack_backlog = backlog;
781 sk->sk_state = TCP_LISTEN;
793 * XXX: when creating ax25_sock we should update the .obj_size setting
796 static struct proto ax25_proto = {
798 .owner = THIS_MODULE,
799 .obj_size = sizeof(struct sock),
802 static int ax25_create(struct net *net, struct socket *sock, int protocol)
807 if (net != &init_net)
808 return -EAFNOSUPPORT;
810 switch (sock->type) {
812 if (protocol == 0 || protocol == PF_AX25)
813 protocol = AX25_P_TEXT;
819 case PF_AX25: /* For CLX */
820 protocol = AX25_P_TEXT;
833 return -ESOCKTNOSUPPORT;
834 #ifdef CONFIG_NETROM_MODULE
836 if (ax25_protocol_is_registered(AX25_P_NETROM))
837 return -ESOCKTNOSUPPORT;
839 #ifdef CONFIG_ROSE_MODULE
841 if (ax25_protocol_is_registered(AX25_P_ROSE))
842 return -ESOCKTNOSUPPORT;
852 return -ESOCKTNOSUPPORT;
855 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
859 ax25 = sk->sk_protinfo = ax25_create_cb();
865 sock_init_data(sock, sk);
867 sk->sk_destruct = ax25_free_sock;
868 sock->ops = &ax25_proto_ops;
869 sk->sk_protocol = protocol;
876 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
879 ax25_cb *ax25, *oax25;
881 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
885 if ((ax25 = ax25_create_cb()) == NULL) {
890 switch (osk->sk_type) {
901 sock_init_data(NULL, sk);
903 sk->sk_type = osk->sk_type;
904 sk->sk_priority = osk->sk_priority;
905 sk->sk_protocol = osk->sk_protocol;
906 sk->sk_rcvbuf = osk->sk_rcvbuf;
907 sk->sk_sndbuf = osk->sk_sndbuf;
908 sk->sk_state = TCP_ESTABLISHED;
909 sock_copy_flags(sk, osk);
911 oax25 = ax25_sk(osk);
913 ax25->modulus = oax25->modulus;
914 ax25->backoff = oax25->backoff;
915 ax25->pidincl = oax25->pidincl;
916 ax25->iamdigi = oax25->iamdigi;
917 ax25->rtt = oax25->rtt;
918 ax25->t1 = oax25->t1;
919 ax25->t2 = oax25->t2;
920 ax25->t3 = oax25->t3;
921 ax25->n2 = oax25->n2;
922 ax25->idle = oax25->idle;
923 ax25->paclen = oax25->paclen;
924 ax25->window = oax25->window;
926 ax25->ax25_dev = ax25_dev;
927 ax25->source_addr = oax25->source_addr;
929 if (oax25->digipeat != NULL) {
930 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
932 if (ax25->digipeat == NULL) {
939 sk->sk_protinfo = ax25;
940 sk->sk_destruct = ax25_free_sock;
946 static int ax25_release(struct socket *sock)
948 struct sock *sk = sock->sk;
959 if (sk->sk_type == SOCK_SEQPACKET) {
960 switch (ax25->state) {
963 ax25_disconnect(ax25, 0);
965 ax25_destroy_socket(ax25);
970 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
972 ax25_disconnect(ax25, 0);
974 ax25_destroy_socket(ax25);
979 ax25_clear_queues(ax25);
982 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
983 case AX25_PROTO_STD_SIMPLEX:
984 case AX25_PROTO_STD_DUPLEX:
985 ax25_send_control(ax25,
989 ax25_stop_t2timer(ax25);
990 ax25_stop_t3timer(ax25);
991 ax25_stop_idletimer(ax25);
993 #ifdef CONFIG_AX25_DAMA_SLAVE
994 case AX25_PROTO_DAMA_SLAVE:
995 ax25_stop_t3timer(ax25);
996 ax25_stop_idletimer(ax25);
1000 ax25_calculate_t1(ax25);
1001 ax25_start_t1timer(ax25);
1002 ax25->state = AX25_STATE_2;
1003 sk->sk_state = TCP_CLOSE;
1004 sk->sk_shutdown |= SEND_SHUTDOWN;
1005 sk->sk_state_change(sk);
1006 sock_set_flag(sk, SOCK_DESTROY);
1013 sk->sk_state = TCP_CLOSE;
1014 sk->sk_shutdown |= SEND_SHUTDOWN;
1015 sk->sk_state_change(sk);
1016 ax25_destroy_socket(ax25);
1027 * We support a funny extension here so you can (as root) give any callsign
1028 * digipeated via a local address as source. This hack is obsolete now
1029 * that we've implemented support for SO_BINDTODEVICE. It is however small
1030 * and trivially backward compatible.
1032 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1034 struct sock *sk = sock->sk;
1035 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1036 ax25_dev *ax25_dev = NULL;
1037 ax25_uid_assoc *user;
1042 if (addr_len != sizeof(struct sockaddr_ax25) &&
1043 addr_len != sizeof(struct full_sockaddr_ax25))
1044 /* support for old structure may go away some time
1045 * ax25_bind(): uses old (6 digipeater) socket structure.
1047 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1048 (addr_len > sizeof(struct full_sockaddr_ax25)))
1051 if (addr->fsa_ax25.sax25_family != AF_AX25)
1054 user = ax25_findbyuid(current_euid());
1059 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1062 call = addr->fsa_ax25.sax25_call;
1068 if (!sock_flag(sk, SOCK_ZAPPED)) {
1073 ax25->source_addr = call;
1076 * User already set interface with SO_BINDTODEVICE
1078 if (ax25->ax25_dev != NULL)
1081 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1082 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1083 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1084 err = -EADDRNOTAVAIL;
1088 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1089 err = -EADDRNOTAVAIL;
1094 if (ax25_dev != NULL)
1095 ax25_fillin_cb(ax25, ax25_dev);
1099 sock_reset_flag(sk, SOCK_ZAPPED);
1108 * FIXME: nonblock behaviour looks like it may have a bug.
1110 static int __must_check ax25_connect(struct socket *sock,
1111 struct sockaddr *uaddr, int addr_len, int flags)
1113 struct sock *sk = sock->sk;
1114 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1115 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1116 ax25_digi *digi = NULL;
1117 int ct = 0, err = 0;
1120 * some sanity checks. code further down depends on this
1123 if (addr_len == sizeof(struct sockaddr_ax25))
1124 /* support for this will go away in early 2.5.x
1125 * ax25_connect(): uses obsolete socket structure
1128 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1129 /* support for old structure may go away some time
1130 * ax25_connect(): uses old (6 digipeater) socket structure.
1132 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1133 (addr_len > sizeof(struct full_sockaddr_ax25)))
1137 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1142 /* deal with restarts */
1143 if (sock->state == SS_CONNECTING) {
1144 switch (sk->sk_state) {
1145 case TCP_SYN_SENT: /* still trying */
1149 case TCP_ESTABLISHED: /* connection established */
1150 sock->state = SS_CONNECTED;
1153 case TCP_CLOSE: /* connection refused */
1154 sock->state = SS_UNCONNECTED;
1155 err = -ECONNREFUSED;
1160 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1161 err = -EISCONN; /* No reconnect on a seqpacket socket */
1165 sk->sk_state = TCP_CLOSE;
1166 sock->state = SS_UNCONNECTED;
1168 kfree(ax25->digipeat);
1169 ax25->digipeat = NULL;
1172 * Handle digi-peaters to be used.
1174 if (addr_len > sizeof(struct sockaddr_ax25) &&
1175 fsa->fsa_ax25.sax25_ndigis != 0) {
1176 /* Valid number of digipeaters ? */
1177 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1182 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1187 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1188 digi->lastrepeat = -1;
1190 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1191 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1192 AX25_HBIT) && ax25->iamdigi) {
1193 digi->repeated[ct] = 1;
1194 digi->lastrepeat = ct;
1196 digi->repeated[ct] = 0;
1198 digi->calls[ct] = fsa->fsa_digipeater[ct];
1204 * Must bind first - autobinding in this may or may not work. If
1205 * the socket is already bound, check to see if the device has
1206 * been filled in, error if it hasn't.
1208 if (sock_flag(sk, SOCK_ZAPPED)) {
1209 /* check if we can remove this feature. It is broken. */
1210 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1212 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1217 ax25_fillin_cb(ax25, ax25->ax25_dev);
1220 if (ax25->ax25_dev == NULL) {
1222 err = -EHOSTUNREACH;
1227 if (sk->sk_type == SOCK_SEQPACKET &&
1228 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1229 ax25->ax25_dev->dev))) {
1231 err = -EADDRINUSE; /* Already such a connection */
1236 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1237 ax25->digipeat = digi;
1239 /* First the easy one */
1240 if (sk->sk_type != SOCK_SEQPACKET) {
1241 sock->state = SS_CONNECTED;
1242 sk->sk_state = TCP_ESTABLISHED;
1246 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1247 sock->state = SS_CONNECTING;
1248 sk->sk_state = TCP_SYN_SENT;
1250 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1251 case AX25_PROTO_STD_SIMPLEX:
1252 case AX25_PROTO_STD_DUPLEX:
1253 ax25_std_establish_data_link(ax25);
1256 #ifdef CONFIG_AX25_DAMA_SLAVE
1257 case AX25_PROTO_DAMA_SLAVE:
1258 ax25->modulus = AX25_MODULUS;
1259 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1260 if (ax25->ax25_dev->dama.slave)
1261 ax25_ds_establish_data_link(ax25);
1263 ax25_std_establish_data_link(ax25);
1268 ax25->state = AX25_STATE_1;
1270 ax25_start_heartbeat(ax25);
1273 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1278 if (sk->sk_state == TCP_SYN_SENT) {
1282 prepare_to_wait(sk->sk_sleep, &wait,
1283 TASK_INTERRUPTIBLE);
1284 if (sk->sk_state != TCP_SYN_SENT)
1286 if (!signal_pending(current)) {
1295 finish_wait(sk->sk_sleep, &wait);
1301 if (sk->sk_state != TCP_ESTABLISHED) {
1302 /* Not in ABM, not in WAIT_UA -> failed */
1303 sock->state = SS_UNCONNECTED;
1304 err = sock_error(sk); /* Always set at this point */
1308 sock->state = SS_CONNECTED;
1317 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1319 struct sk_buff *skb;
1325 if (sock->state != SS_UNCONNECTED)
1328 if ((sk = sock->sk) == NULL)
1332 if (sk->sk_type != SOCK_SEQPACKET) {
1337 if (sk->sk_state != TCP_LISTEN) {
1343 * The read queue this time is holding sockets ready to use
1344 * hooked into the SABM we saved
1347 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1348 skb = skb_dequeue(&sk->sk_receive_queue);
1352 if (flags & O_NONBLOCK) {
1356 if (!signal_pending(current)) {
1365 finish_wait(sk->sk_sleep, &wait);
1371 sock_graft(newsk, newsock);
1373 /* Now attach up the new socket */
1375 sk->sk_ack_backlog--;
1376 newsock->state = SS_CONNECTED;
1384 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1385 int *uaddr_len, int peer)
1387 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1388 struct sock *sk = sock->sk;
1389 unsigned char ndigi, i;
1397 if (sk->sk_state != TCP_ESTABLISHED) {
1402 fsa->fsa_ax25.sax25_family = AF_AX25;
1403 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1404 fsa->fsa_ax25.sax25_ndigis = 0;
1406 if (ax25->digipeat != NULL) {
1407 ndigi = ax25->digipeat->ndigi;
1408 fsa->fsa_ax25.sax25_ndigis = ndigi;
1409 for (i = 0; i < ndigi; i++)
1410 fsa->fsa_digipeater[i] =
1411 ax25->digipeat->calls[i];
1414 fsa->fsa_ax25.sax25_family = AF_AX25;
1415 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1416 fsa->fsa_ax25.sax25_ndigis = 1;
1417 if (ax25->ax25_dev != NULL) {
1418 memcpy(&fsa->fsa_digipeater[0],
1419 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1421 fsa->fsa_digipeater[0] = null_ax25_address;
1424 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1432 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1433 struct msghdr *msg, size_t len)
1435 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1436 struct sock *sk = sock->sk;
1437 struct sockaddr_ax25 sax;
1438 struct sk_buff *skb;
1439 ax25_digi dtmp, *dp;
1442 int lv, err, addr_len = msg->msg_namelen;
1444 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1450 if (sock_flag(sk, SOCK_ZAPPED)) {
1451 err = -EADDRNOTAVAIL;
1455 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1456 send_sig(SIGPIPE, current, 0);
1461 if (ax25->ax25_dev == NULL) {
1466 if (len > ax25->ax25_dev->dev->mtu) {
1472 if (usax->sax25_family != AF_AX25) {
1477 if (addr_len == sizeof(struct sockaddr_ax25))
1478 /* ax25_sendmsg(): uses obsolete socket structure */
1480 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1481 /* support for old structure may go away some time
1482 * ax25_sendmsg(): uses old (6 digipeater)
1485 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1486 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1492 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1494 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1496 /* Valid number of digipeaters ? */
1497 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1502 dtmp.ndigi = usax->sax25_ndigis;
1504 while (ct < usax->sax25_ndigis) {
1505 dtmp.repeated[ct] = 0;
1506 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1510 dtmp.lastrepeat = 0;
1514 if (sk->sk_type == SOCK_SEQPACKET &&
1515 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1519 if (usax->sax25_ndigis == 0)
1525 * FIXME: 1003.1g - if the socket is like this because
1526 * it has become closed (not started closed) and is VC
1527 * we ought to SIGPIPE, EPIPE
1529 if (sk->sk_state != TCP_ESTABLISHED) {
1533 sax.sax25_family = AF_AX25;
1534 sax.sax25_call = ax25->dest_addr;
1535 dp = ax25->digipeat;
1538 /* Build a packet */
1539 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built. Building packet.\n");
1541 /* Assume the worst case */
1542 size = len + ax25->ax25_dev->dev->hard_header_len;
1544 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1548 skb_reserve(skb, size - len);
1550 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1552 /* User data follows immediately after the AX.25 data */
1553 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1559 skb_reset_network_header(skb);
1561 /* Add the PID if one is not supplied by the user in the skb */
1563 *skb_push(skb, 1) = sk->sk_protocol;
1565 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1567 if (sk->sk_type == SOCK_SEQPACKET) {
1568 /* Connected mode sockets go via the LAPB machine */
1569 if (sk->sk_state != TCP_ESTABLISHED) {
1575 /* Shove it onto the queue and kick */
1576 ax25_output(ax25, ax25->paclen, skb);
1582 skb_push(skb, 1 + ax25_addr_size(dp));
1584 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1587 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1589 /* Build an AX.25 header */
1590 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1591 dp, AX25_COMMAND, AX25_MODULUS);
1593 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1595 skb_set_transport_header(skb, lv);
1597 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1598 skb->data, skb_transport_header(skb));
1600 *skb_transport_header(skb) = AX25_UI;
1602 /* Datagram frames go straight out of the door as UI */
1603 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1613 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1614 struct msghdr *msg, size_t size, int flags)
1616 struct sock *sk = sock->sk;
1617 struct sk_buff *skb;
1623 * This works for seqpacket too. The receiver has ordered the
1624 * queue for us! We do one quick check first though
1626 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1631 /* Now we can treat all alike */
1632 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1633 flags & MSG_DONTWAIT, &err);
1637 if (!ax25_sk(sk)->pidincl)
1638 skb_pull(skb, 1); /* Remove PID */
1640 skb_reset_transport_header(skb);
1643 if (copied > size) {
1645 msg->msg_flags |= MSG_TRUNC;
1648 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1650 if (msg->msg_namelen != 0) {
1651 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1654 const unsigned char *mac = skb_mac_header(skb);
1656 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1658 sax->sax25_family = AF_AX25;
1659 /* We set this correctly, even though we may not let the
1660 application know the digi calls further down (because it
1661 did NOT ask to know them). This could get political... **/
1662 sax->sax25_ndigis = digi.ndigi;
1663 sax->sax25_call = src;
1665 if (sax->sax25_ndigis != 0) {
1667 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1669 for (ct = 0; ct < digi.ndigi; ct++)
1670 fsa->fsa_digipeater[ct] = digi.calls[ct];
1672 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1675 skb_free_datagram(sk, skb);
1684 static int ax25_shutdown(struct socket *sk, int how)
1686 /* FIXME - generate DM and RNR states */
1690 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1692 struct sock *sk = sock->sk;
1693 void __user *argp = (void __user *)arg;
1701 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1704 res = put_user(amount, (int __user *)argp);
1709 struct sk_buff *skb;
1711 /* These two are safe on a single CPU system as only user tasks fiddle here */
1712 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1714 res = put_user(amount, (int __user *) argp);
1719 res = sock_get_timestamp(sk, argp);
1723 res = sock_get_timestampns(sk, argp);
1726 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1727 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1728 case SIOCAX25GETUID: {
1729 struct sockaddr_ax25 sax25;
1730 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1734 res = ax25_uid_ioctl(cmd, &sax25);
1738 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1740 if (!capable(CAP_NET_ADMIN)) {
1744 if (get_user(amount, (long __user *)argp)) {
1748 if (amount > AX25_NOUID_BLOCK) {
1752 ax25_uid_policy = amount;
1760 if (!capable(CAP_NET_ADMIN)) {
1764 res = ax25_rt_ioctl(cmd, argp);
1767 case SIOCAX25CTLCON:
1768 if (!capable(CAP_NET_ADMIN)) {
1772 res = ax25_ctl_ioctl(cmd, argp);
1775 case SIOCAX25GETINFO:
1776 case SIOCAX25GETINFOOLD: {
1777 ax25_cb *ax25 = ax25_sk(sk);
1778 struct ax25_info_struct ax25_info;
1780 ax25_info.t1 = ax25->t1 / HZ;
1781 ax25_info.t2 = ax25->t2 / HZ;
1782 ax25_info.t3 = ax25->t3 / HZ;
1783 ax25_info.idle = ax25->idle / (60 * HZ);
1784 ax25_info.n2 = ax25->n2;
1785 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1786 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1787 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1788 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1789 ax25_info.n2count = ax25->n2count;
1790 ax25_info.state = ax25->state;
1791 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1792 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1793 ax25_info.vs = ax25->vs;
1794 ax25_info.vr = ax25->vr;
1795 ax25_info.va = ax25->va;
1796 ax25_info.vs_max = ax25->vs; /* reserved */
1797 ax25_info.paclen = ax25->paclen;
1798 ax25_info.window = ax25->window;
1800 /* old structure? */
1801 if (cmd == SIOCAX25GETINFOOLD) {
1802 static int warned = 0;
1804 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1809 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1814 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1823 case SIOCAX25ADDFWD:
1824 case SIOCAX25DELFWD: {
1825 struct ax25_fwd_struct ax25_fwd;
1826 if (!capable(CAP_NET_ADMIN)) {
1830 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1834 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1840 case SIOCGIFDSTADDR:
1841 case SIOCSIFDSTADDR:
1842 case SIOCGIFBRDADDR:
1843 case SIOCSIFBRDADDR:
1844 case SIOCGIFNETMASK:
1845 case SIOCSIFNETMASK:
1860 #ifdef CONFIG_PROC_FS
1862 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1863 __acquires(ax25_list_lock)
1865 struct ax25_cb *ax25;
1866 struct hlist_node *node;
1869 spin_lock_bh(&ax25_list_lock);
1870 ax25_for_each(ax25, node, &ax25_list) {
1878 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1882 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1883 struct ax25_cb, ax25_node);
1886 static void ax25_info_stop(struct seq_file *seq, void *v)
1887 __releases(ax25_list_lock)
1889 spin_unlock_bh(&ax25_list_lock);
1892 static int ax25_info_show(struct seq_file *seq, void *v)
1901 * 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
1904 seq_printf(seq, "%8.8lx %s %s%s ",
1906 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1907 ax2asc(buf, &ax25->source_addr),
1908 ax25->iamdigi? "*":"");
1909 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1911 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1912 seq_printf(seq, ",%s%s",
1913 ax2asc(buf, &ax25->digipeat->calls[k]),
1914 ax25->digipeat->repeated[k]? "*":"");
1917 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1919 ax25->vs, ax25->vr, ax25->va,
1920 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1921 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1922 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1923 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1924 ax25->idle / (60 * HZ),
1925 ax25->n2count, ax25->n2,
1930 if (ax25->sk != NULL) {
1931 seq_printf(seq, " %d %d %lu\n",
1932 sk_wmem_alloc_get(ax25->sk),
1933 sk_rmem_alloc_get(ax25->sk),
1934 sock_i_ino(ax25->sk));
1936 seq_puts(seq, " * * *\n");
1941 static const struct seq_operations ax25_info_seqops = {
1942 .start = ax25_info_start,
1943 .next = ax25_info_next,
1944 .stop = ax25_info_stop,
1945 .show = ax25_info_show,
1948 static int ax25_info_open(struct inode *inode, struct file *file)
1950 return seq_open(file, &ax25_info_seqops);
1953 static const struct file_operations ax25_info_fops = {
1954 .owner = THIS_MODULE,
1955 .open = ax25_info_open,
1957 .llseek = seq_lseek,
1958 .release = seq_release,
1963 static const struct net_proto_family ax25_family_ops = {
1965 .create = ax25_create,
1966 .owner = THIS_MODULE,
1969 static const struct proto_ops ax25_proto_ops = {
1971 .owner = THIS_MODULE,
1972 .release = ax25_release,
1974 .connect = ax25_connect,
1975 .socketpair = sock_no_socketpair,
1976 .accept = ax25_accept,
1977 .getname = ax25_getname,
1978 .poll = datagram_poll,
1979 .ioctl = ax25_ioctl,
1980 .listen = ax25_listen,
1981 .shutdown = ax25_shutdown,
1982 .setsockopt = ax25_setsockopt,
1983 .getsockopt = ax25_getsockopt,
1984 .sendmsg = ax25_sendmsg,
1985 .recvmsg = ax25_recvmsg,
1986 .mmap = sock_no_mmap,
1987 .sendpage = sock_no_sendpage,
1991 * Called by socket.c on kernel start up
1993 static struct packet_type ax25_packet_type __read_mostly = {
1994 .type = cpu_to_be16(ETH_P_AX25),
1995 .func = ax25_kiss_rcv,
1998 static struct notifier_block ax25_dev_notifier = {
1999 .notifier_call =ax25_device_event,
2002 static int __init ax25_init(void)
2004 int rc = proto_register(&ax25_proto, 0);
2009 sock_register(&ax25_family_ops);
2010 dev_add_pack(&ax25_packet_type);
2011 register_netdevice_notifier(&ax25_dev_notifier);
2012 ax25_register_sysctl();
2014 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2015 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2016 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
2020 module_init(ax25_init);
2023 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2024 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2025 MODULE_LICENSE("GPL");
2026 MODULE_ALIAS_NETPROTO(PF_AX25);
2028 static void __exit ax25_exit(void)
2030 proc_net_remove(&init_net, "ax25_route");
2031 proc_net_remove(&init_net, "ax25");
2032 proc_net_remove(&init_net, "ax25_calls");
2037 ax25_unregister_sysctl();
2038 unregister_netdevice_notifier(&ax25_dev_notifier);
2040 dev_remove_pack(&ax25_packet_type);
2042 sock_unregister(PF_AX25);
2043 proto_unregister(&ax25_proto);
2045 module_exit(ax25_exit);