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);
90 ax25_for_each(s, node, &ax25_list) {
91 if (s->ax25_dev == ax25_dev) {
93 ax25_disconnect(s, ENETUNREACH);
96 spin_unlock_bh(&ax25_list_lock);
100 * Handle device status changes.
102 static int ax25_device_event(struct notifier_block *this, unsigned long event,
105 struct net_device *dev = (struct net_device *)ptr;
107 if (dev->nd_net != &init_net)
110 /* Reject non AX.25 devices */
111 if (dev->type != ARPHRD_AX25)
116 ax25_dev_device_up(dev);
119 ax25_kill_by_device(dev);
120 ax25_rt_device_down(dev);
121 ax25_dev_device_down(dev);
131 * Add a socket to the bound sockets list.
133 void ax25_cb_add(ax25_cb *ax25)
135 spin_lock_bh(&ax25_list_lock);
137 hlist_add_head(&ax25->ax25_node, &ax25_list);
138 spin_unlock_bh(&ax25_list_lock);
142 * Find a socket that wants to accept the SABM we have just
145 struct sock *ax25_find_listener(ax25_address *addr, int digi,
146 struct net_device *dev, int type)
149 struct hlist_node *node;
151 spin_lock(&ax25_list_lock);
152 ax25_for_each(s, node, &ax25_list) {
153 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
155 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
156 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
157 /* If device is null we match any device */
158 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
160 spin_unlock(&ax25_list_lock);
165 spin_unlock(&ax25_list_lock);
171 * Find an AX.25 socket given both ends.
173 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
176 struct sock *sk = NULL;
178 struct hlist_node *node;
180 spin_lock(&ax25_list_lock);
181 ax25_for_each(s, node, &ax25_list) {
182 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
183 !ax25cmp(&s->dest_addr, dest_addr) &&
184 s->sk->sk_type == type) {
191 spin_unlock(&ax25_list_lock);
197 * Find an AX.25 control block given both ends. It will only pick up
198 * floating AX.25 control blocks or non Raw socket bound control blocks.
200 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
201 ax25_digi *digi, struct net_device *dev)
204 struct hlist_node *node;
206 spin_lock_bh(&ax25_list_lock);
207 ax25_for_each(s, node, &ax25_list) {
208 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
210 if (s->ax25_dev == NULL)
212 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
213 if (digi != NULL && digi->ndigi != 0) {
214 if (s->digipeat == NULL)
216 if (ax25digicmp(s->digipeat, digi) != 0)
219 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
223 spin_unlock_bh(&ax25_list_lock);
228 spin_unlock_bh(&ax25_list_lock);
233 EXPORT_SYMBOL(ax25_find_cb);
235 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
238 struct sk_buff *copy;
239 struct hlist_node *node;
241 spin_lock(&ax25_list_lock);
242 ax25_for_each(s, node, &ax25_list) {
243 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
244 s->sk->sk_type == SOCK_RAW &&
245 s->sk->sk_protocol == proto &&
246 s->ax25_dev->dev == skb->dev &&
247 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
248 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
250 if (sock_queue_rcv_skb(s->sk, copy) != 0)
254 spin_unlock(&ax25_list_lock);
260 void ax25_destroy_socket(ax25_cb *);
263 * Handler for deferred kills.
265 static void ax25_destroy_timer(unsigned long data)
267 ax25_cb *ax25=(ax25_cb *)data;
274 ax25_destroy_socket(ax25);
280 * This is called from user mode and the timers. Thus it protects itself
281 * against interrupt users but doesn't worry about being called during
282 * work. Once it is removed from the queue no interrupt or bottom half
283 * will touch it and we are (fairly 8-) ) safe.
285 void ax25_destroy_socket(ax25_cb *ax25)
291 ax25_stop_heartbeat(ax25);
292 ax25_stop_t1timer(ax25);
293 ax25_stop_t2timer(ax25);
294 ax25_stop_t3timer(ax25);
295 ax25_stop_idletimer(ax25);
297 ax25_clear_queues(ax25); /* Flush the queues */
299 if (ax25->sk != NULL) {
300 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
301 if (skb->sk != ax25->sk) {
302 /* A pending connection */
303 ax25_cb *sax25 = ax25_sk(skb->sk);
305 /* Queue the unaccepted socket for death */
306 sock_orphan(skb->sk);
308 ax25_start_heartbeat(sax25);
309 sax25->state = AX25_STATE_0;
314 skb_queue_purge(&ax25->sk->sk_write_queue);
317 if (ax25->sk != NULL) {
318 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
319 atomic_read(&ax25->sk->sk_rmem_alloc)) {
320 /* Defer: outstanding buffers */
321 init_timer(&ax25->dtimer);
322 ax25->dtimer.expires = jiffies + 2 * HZ;
323 ax25->dtimer.function = ax25_destroy_timer;
324 ax25->dtimer.data = (unsigned long)ax25;
325 add_timer(&ax25->dtimer);
327 struct sock *sk=ax25->sk;
337 * dl1bke 960311: set parameters for existing AX.25 connections,
338 * includes a KILL command to abort any connection.
339 * VERY useful for debugging ;-)
341 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
343 struct ax25_ctl_struct ax25_ctl;
349 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
352 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
355 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
358 digi.ndigi = ax25_ctl.digi_count;
359 for (k = 0; k < digi.ndigi; k++)
360 digi.calls[k] = ax25_ctl.digi_addr[k];
362 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
365 switch (ax25_ctl.cmd) {
367 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
368 #ifdef CONFIG_AX25_DAMA_SLAVE
369 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
372 ax25_disconnect(ax25, ENETRESET);
376 if (ax25->modulus == AX25_MODULUS) {
377 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
380 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
383 ax25->window = ax25_ctl.arg;
387 if (ax25_ctl.arg < 1)
389 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
390 ax25->t1 = ax25_ctl.arg * HZ;
394 if (ax25_ctl.arg < 1)
396 ax25->t2 = ax25_ctl.arg * HZ;
400 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
403 ax25->n2 = ax25_ctl.arg;
407 if (ax25_ctl.arg < 0)
409 ax25->t3 = ax25_ctl.arg * HZ;
413 if (ax25_ctl.arg < 0)
415 ax25->idle = ax25_ctl.arg * 60 * HZ;
419 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
421 ax25->paclen = ax25_ctl.arg;
431 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
433 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
434 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
435 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
436 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
437 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
438 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
439 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
440 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
442 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
443 ax25->modulus = AX25_EMODULUS;
444 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
446 ax25->modulus = AX25_MODULUS;
447 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
452 * Fill in a created AX.25 created control block with the default
453 * values for a particular device.
455 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
457 ax25->ax25_dev = ax25_dev;
459 if (ax25->ax25_dev != NULL) {
460 ax25_fillin_cb_from_dev(ax25, ax25_dev);
465 * No device, use kernel / AX.25 spec default values
467 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
468 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
469 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
470 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
471 ax25->n2 = AX25_DEF_N2;
472 ax25->paclen = AX25_DEF_PACLEN;
473 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
474 ax25->backoff = AX25_DEF_BACKOFF;
476 if (AX25_DEF_AXDEFMODE) {
477 ax25->modulus = AX25_EMODULUS;
478 ax25->window = AX25_DEF_EWINDOW;
480 ax25->modulus = AX25_MODULUS;
481 ax25->window = AX25_DEF_WINDOW;
486 * Create an empty AX.25 control block.
488 ax25_cb *ax25_create_cb(void)
492 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
495 atomic_set(&ax25->refcount, 1);
497 skb_queue_head_init(&ax25->write_queue);
498 skb_queue_head_init(&ax25->frag_queue);
499 skb_queue_head_init(&ax25->ack_queue);
500 skb_queue_head_init(&ax25->reseq_queue);
502 init_timer(&ax25->timer);
503 init_timer(&ax25->t1timer);
504 init_timer(&ax25->t2timer);
505 init_timer(&ax25->t3timer);
506 init_timer(&ax25->idletimer);
508 ax25_fillin_cb(ax25, NULL);
510 ax25->state = AX25_STATE_0;
516 * Handling for system calls applied via the various interfaces to an
520 static int ax25_setsockopt(struct socket *sock, int level, int optname,
521 char __user *optval, int optlen)
523 struct sock *sk = sock->sk;
525 struct net_device *dev;
526 char devname[IFNAMSIZ];
529 if (level != SOL_AX25)
532 if (optlen < sizeof(int))
535 if (get_user(opt, (int __user *)optval))
543 if (ax25->modulus == AX25_MODULUS) {
544 if (opt < 1 || opt > 7) {
549 if (opt < 1 || opt > 63) {
562 ax25->rtt = (opt * HZ) / 2;
575 if (opt < 1 || opt > 31) {
595 ax25->idle = opt * 60 * HZ;
599 if (opt < 0 || opt > 2) {
607 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
611 ax25->pidincl = opt ? 1 : 0;
615 ax25->iamdigi = opt ? 1 : 0;
619 if (opt < 16 || opt > 65535) {
626 case SO_BINDTODEVICE:
627 if (optlen > IFNAMSIZ)
629 if (copy_from_user(devname, optval, optlen)) {
634 dev = dev_get_by_name(&init_net, devname);
640 if (sk->sk_type == SOCK_SEQPACKET &&
641 (sock->state != SS_UNCONNECTED ||
642 sk->sk_state == TCP_LISTEN)) {
643 res = -EADDRNOTAVAIL;
648 ax25->ax25_dev = ax25_dev_ax25dev(dev);
649 ax25_fillin_cb(ax25, ax25->ax25_dev);
660 static int ax25_getsockopt(struct socket *sock, int level, int optname,
661 char __user *optval, int __user *optlen)
663 struct sock *sk = sock->sk;
665 struct ax25_dev *ax25_dev;
666 char devname[IFNAMSIZ];
671 if (level != SOL_AX25)
674 if (get_user(maxlen, optlen))
680 valptr = (void *) &val;
681 length = min_t(unsigned int, maxlen, sizeof(int));
708 val = ax25->idle / (60 * HZ);
716 val = (ax25->modulus == AX25_EMODULUS);
731 case SO_BINDTODEVICE:
732 ax25_dev = ax25->ax25_dev;
734 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
735 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
736 length = strlen(devname) + 1;
742 valptr = (void *) devname;
751 if (put_user(length, optlen))
754 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
757 static int ax25_listen(struct socket *sock, int backlog)
759 struct sock *sk = sock->sk;
763 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
764 sk->sk_max_ack_backlog = backlog;
765 sk->sk_state = TCP_LISTEN;
777 * XXX: when creating ax25_sock we should update the .obj_size setting
780 static struct proto ax25_proto = {
782 .owner = THIS_MODULE,
783 .obj_size = sizeof(struct sock),
786 static int ax25_create(struct net *net, struct socket *sock, int protocol)
791 if (net != &init_net)
792 return -EAFNOSUPPORT;
794 switch (sock->type) {
796 if (protocol == 0 || protocol == PF_AX25)
797 protocol = AX25_P_TEXT;
803 case PF_AX25: /* For CLX */
804 protocol = AX25_P_TEXT;
817 return -ESOCKTNOSUPPORT;
818 #ifdef CONFIG_NETROM_MODULE
820 if (ax25_protocol_is_registered(AX25_P_NETROM))
821 return -ESOCKTNOSUPPORT;
823 #ifdef CONFIG_ROSE_MODULE
825 if (ax25_protocol_is_registered(AX25_P_ROSE))
826 return -ESOCKTNOSUPPORT;
836 return -ESOCKTNOSUPPORT;
839 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
843 ax25 = sk->sk_protinfo = ax25_create_cb();
849 sock_init_data(sock, sk);
851 sk->sk_destruct = ax25_free_sock;
852 sock->ops = &ax25_proto_ops;
853 sk->sk_protocol = protocol;
860 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
863 ax25_cb *ax25, *oax25;
865 sk = sk_alloc(osk->sk_net, PF_AX25, GFP_ATOMIC, osk->sk_prot);
869 if ((ax25 = ax25_create_cb()) == NULL) {
874 switch (osk->sk_type) {
885 sock_init_data(NULL, sk);
887 sk->sk_destruct = ax25_free_sock;
888 sk->sk_type = osk->sk_type;
889 sk->sk_socket = osk->sk_socket;
890 sk->sk_priority = osk->sk_priority;
891 sk->sk_protocol = osk->sk_protocol;
892 sk->sk_rcvbuf = osk->sk_rcvbuf;
893 sk->sk_sndbuf = osk->sk_sndbuf;
894 sk->sk_state = TCP_ESTABLISHED;
895 sk->sk_sleep = osk->sk_sleep;
896 sock_copy_flags(sk, osk);
898 oax25 = ax25_sk(osk);
900 ax25->modulus = oax25->modulus;
901 ax25->backoff = oax25->backoff;
902 ax25->pidincl = oax25->pidincl;
903 ax25->iamdigi = oax25->iamdigi;
904 ax25->rtt = oax25->rtt;
905 ax25->t1 = oax25->t1;
906 ax25->t2 = oax25->t2;
907 ax25->t3 = oax25->t3;
908 ax25->n2 = oax25->n2;
909 ax25->idle = oax25->idle;
910 ax25->paclen = oax25->paclen;
911 ax25->window = oax25->window;
913 ax25->ax25_dev = ax25_dev;
914 ax25->source_addr = oax25->source_addr;
916 if (oax25->digipeat != NULL) {
917 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
919 if (ax25->digipeat == NULL) {
926 sk->sk_protinfo = ax25;
932 static int ax25_release(struct socket *sock)
934 struct sock *sk = sock->sk;
945 if (sk->sk_type == SOCK_SEQPACKET) {
946 switch (ax25->state) {
949 ax25_disconnect(ax25, 0);
951 ax25_destroy_socket(ax25);
956 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
958 ax25_disconnect(ax25, 0);
960 ax25_destroy_socket(ax25);
965 ax25_clear_queues(ax25);
968 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
969 case AX25_PROTO_STD_SIMPLEX:
970 case AX25_PROTO_STD_DUPLEX:
971 ax25_send_control(ax25,
975 ax25_stop_t2timer(ax25);
976 ax25_stop_t3timer(ax25);
977 ax25_stop_idletimer(ax25);
979 #ifdef CONFIG_AX25_DAMA_SLAVE
980 case AX25_PROTO_DAMA_SLAVE:
981 ax25_stop_t3timer(ax25);
982 ax25_stop_idletimer(ax25);
986 ax25_calculate_t1(ax25);
987 ax25_start_t1timer(ax25);
988 ax25->state = AX25_STATE_2;
989 sk->sk_state = TCP_CLOSE;
990 sk->sk_shutdown |= SEND_SHUTDOWN;
991 sk->sk_state_change(sk);
992 sock_set_flag(sk, SOCK_DESTROY);
999 sk->sk_state = TCP_CLOSE;
1000 sk->sk_shutdown |= SEND_SHUTDOWN;
1001 sk->sk_state_change(sk);
1002 ax25_destroy_socket(ax25);
1013 * We support a funny extension here so you can (as root) give any callsign
1014 * digipeated via a local address as source. This hack is obsolete now
1015 * that we've implemented support for SO_BINDTODEVICE. It is however small
1016 * and trivially backward compatible.
1018 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1020 struct sock *sk = sock->sk;
1021 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1022 ax25_dev *ax25_dev = NULL;
1023 ax25_uid_assoc *user;
1028 if (addr_len != sizeof(struct sockaddr_ax25) &&
1029 addr_len != sizeof(struct full_sockaddr_ax25)) {
1030 /* support for old structure may go away some time */
1031 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1032 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1036 printk(KERN_WARNING "ax25_bind(): %s uses old (6 digipeater) socket structure.\n",
1040 if (addr->fsa_ax25.sax25_family != AF_AX25)
1043 user = ax25_findbyuid(current->euid);
1048 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1051 call = addr->fsa_ax25.sax25_call;
1057 if (!sock_flag(sk, SOCK_ZAPPED)) {
1062 ax25->source_addr = call;
1065 * User already set interface with SO_BINDTODEVICE
1067 if (ax25->ax25_dev != NULL)
1070 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1071 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1072 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1073 err = -EADDRNOTAVAIL;
1077 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1078 err = -EADDRNOTAVAIL;
1083 if (ax25_dev != NULL)
1084 ax25_fillin_cb(ax25, ax25_dev);
1088 sock_reset_flag(sk, SOCK_ZAPPED);
1097 * FIXME: nonblock behaviour looks like it may have a bug.
1099 static int __must_check ax25_connect(struct socket *sock,
1100 struct sockaddr *uaddr, int addr_len, int flags)
1102 struct sock *sk = sock->sk;
1103 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1104 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1105 ax25_digi *digi = NULL;
1106 int ct = 0, err = 0;
1109 * some sanity checks. code further down depends on this
1112 if (addr_len == sizeof(struct sockaddr_ax25))
1113 /* support for this will go away in early 2.5.x
1114 * ax25_connect(): uses obsolete socket structure
1117 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1118 /* support for old structure may go away some time
1119 * ax25_connect(): uses old (6 digipeater) socket structure.
1121 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1122 (addr_len > sizeof(struct full_sockaddr_ax25)))
1126 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1131 /* deal with restarts */
1132 if (sock->state == SS_CONNECTING) {
1133 switch (sk->sk_state) {
1134 case TCP_SYN_SENT: /* still trying */
1138 case TCP_ESTABLISHED: /* connection established */
1139 sock->state = SS_CONNECTED;
1142 case TCP_CLOSE: /* connection refused */
1143 sock->state = SS_UNCONNECTED;
1144 err = -ECONNREFUSED;
1149 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1150 err = -EISCONN; /* No reconnect on a seqpacket socket */
1154 sk->sk_state = TCP_CLOSE;
1155 sock->state = SS_UNCONNECTED;
1157 kfree(ax25->digipeat);
1158 ax25->digipeat = NULL;
1161 * Handle digi-peaters to be used.
1163 if (addr_len > sizeof(struct sockaddr_ax25) &&
1164 fsa->fsa_ax25.sax25_ndigis != 0) {
1165 /* Valid number of digipeaters ? */
1166 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1171 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1176 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1177 digi->lastrepeat = -1;
1179 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1180 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1181 AX25_HBIT) && ax25->iamdigi) {
1182 digi->repeated[ct] = 1;
1183 digi->lastrepeat = ct;
1185 digi->repeated[ct] = 0;
1187 digi->calls[ct] = fsa->fsa_digipeater[ct];
1193 * Must bind first - autobinding in this may or may not work. If
1194 * the socket is already bound, check to see if the device has
1195 * been filled in, error if it hasn't.
1197 if (sock_flag(sk, SOCK_ZAPPED)) {
1198 /* check if we can remove this feature. It is broken. */
1199 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1201 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1206 ax25_fillin_cb(ax25, ax25->ax25_dev);
1209 if (ax25->ax25_dev == NULL) {
1211 err = -EHOSTUNREACH;
1216 if (sk->sk_type == SOCK_SEQPACKET &&
1217 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1218 ax25->ax25_dev->dev))) {
1220 err = -EADDRINUSE; /* Already such a connection */
1225 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1226 ax25->digipeat = digi;
1228 /* First the easy one */
1229 if (sk->sk_type != SOCK_SEQPACKET) {
1230 sock->state = SS_CONNECTED;
1231 sk->sk_state = TCP_ESTABLISHED;
1235 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1236 sock->state = SS_CONNECTING;
1237 sk->sk_state = TCP_SYN_SENT;
1239 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1240 case AX25_PROTO_STD_SIMPLEX:
1241 case AX25_PROTO_STD_DUPLEX:
1242 ax25_std_establish_data_link(ax25);
1245 #ifdef CONFIG_AX25_DAMA_SLAVE
1246 case AX25_PROTO_DAMA_SLAVE:
1247 ax25->modulus = AX25_MODULUS;
1248 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1249 if (ax25->ax25_dev->dama.slave)
1250 ax25_ds_establish_data_link(ax25);
1252 ax25_std_establish_data_link(ax25);
1257 ax25->state = AX25_STATE_1;
1259 ax25_start_heartbeat(ax25);
1262 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1267 if (sk->sk_state == TCP_SYN_SENT) {
1271 prepare_to_wait(sk->sk_sleep, &wait,
1272 TASK_INTERRUPTIBLE);
1273 if (sk->sk_state != TCP_SYN_SENT)
1275 if (!signal_pending(current)) {
1284 finish_wait(sk->sk_sleep, &wait);
1290 if (sk->sk_state != TCP_ESTABLISHED) {
1291 /* Not in ABM, not in WAIT_UA -> failed */
1292 sock->state = SS_UNCONNECTED;
1293 err = sock_error(sk); /* Always set at this point */
1297 sock->state = SS_CONNECTED;
1306 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1308 struct sk_buff *skb;
1314 if (sock->state != SS_UNCONNECTED)
1317 if ((sk = sock->sk) == NULL)
1321 if (sk->sk_type != SOCK_SEQPACKET) {
1326 if (sk->sk_state != TCP_LISTEN) {
1332 * The read queue this time is holding sockets ready to use
1333 * hooked into the SABM we saved
1336 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1337 skb = skb_dequeue(&sk->sk_receive_queue);
1341 if (flags & O_NONBLOCK) {
1345 if (!signal_pending(current)) {
1354 finish_wait(sk->sk_sleep, &wait);
1360 newsk->sk_socket = newsock;
1361 newsk->sk_sleep = &newsock->wait;
1363 /* Now attach up the new socket */
1365 sk->sk_ack_backlog--;
1366 newsock->sk = newsk;
1367 newsock->state = SS_CONNECTED;
1375 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1376 int *uaddr_len, int peer)
1378 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1379 struct sock *sk = sock->sk;
1380 unsigned char ndigi, i;
1388 if (sk->sk_state != TCP_ESTABLISHED) {
1393 fsa->fsa_ax25.sax25_family = AF_AX25;
1394 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1395 fsa->fsa_ax25.sax25_ndigis = 0;
1397 if (ax25->digipeat != NULL) {
1398 ndigi = ax25->digipeat->ndigi;
1399 fsa->fsa_ax25.sax25_ndigis = ndigi;
1400 for (i = 0; i < ndigi; i++)
1401 fsa->fsa_digipeater[i] =
1402 ax25->digipeat->calls[i];
1405 fsa->fsa_ax25.sax25_family = AF_AX25;
1406 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1407 fsa->fsa_ax25.sax25_ndigis = 1;
1408 if (ax25->ax25_dev != NULL) {
1409 memcpy(&fsa->fsa_digipeater[0],
1410 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1412 fsa->fsa_digipeater[0] = null_ax25_address;
1415 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1423 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1424 struct msghdr *msg, size_t len)
1426 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1427 struct sock *sk = sock->sk;
1428 struct sockaddr_ax25 sax;
1429 struct sk_buff *skb;
1430 ax25_digi dtmp, *dp;
1433 int lv, err, addr_len = msg->msg_namelen;
1435 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1441 if (sock_flag(sk, SOCK_ZAPPED)) {
1442 err = -EADDRNOTAVAIL;
1446 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1447 send_sig(SIGPIPE, current, 0);
1452 if (ax25->ax25_dev == NULL) {
1457 if (len > ax25->ax25_dev->dev->mtu) {
1463 if (usax->sax25_family != AF_AX25) {
1468 if (addr_len == sizeof(struct sockaddr_ax25))
1469 /* ax25_sendmsg(): uses obsolete socket structure */
1471 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1472 /* support for old structure may go away some time
1473 * ax25_sendmsg(): uses old (6 digipeater)
1476 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1477 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1483 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1485 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1487 /* Valid number of digipeaters ? */
1488 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1493 dtmp.ndigi = usax->sax25_ndigis;
1495 while (ct < usax->sax25_ndigis) {
1496 dtmp.repeated[ct] = 0;
1497 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1501 dtmp.lastrepeat = 0;
1505 if (sk->sk_type == SOCK_SEQPACKET &&
1506 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1510 if (usax->sax25_ndigis == 0)
1516 * FIXME: 1003.1g - if the socket is like this because
1517 * it has become closed (not started closed) and is VC
1518 * we ought to SIGPIPE, EPIPE
1520 if (sk->sk_state != TCP_ESTABLISHED) {
1524 sax.sax25_family = AF_AX25;
1525 sax.sax25_call = ax25->dest_addr;
1526 dp = ax25->digipeat;
1529 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1531 /* Build a packet */
1532 SOCK_DEBUG(sk, "AX.25: sendto: 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;
1693 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1696 res = put_user(amount, (int __user *)argp);
1701 struct sk_buff *skb;
1703 /* These two are safe on a single CPU system as only user tasks fiddle here */
1704 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1706 res = put_user(amount, (int __user *) argp);
1711 res = sock_get_timestamp(sk, argp);
1715 res = sock_get_timestampns(sk, argp);
1718 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1719 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1720 case SIOCAX25GETUID: {
1721 struct sockaddr_ax25 sax25;
1722 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1726 res = ax25_uid_ioctl(cmd, &sax25);
1730 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1732 if (!capable(CAP_NET_ADMIN)) {
1736 if (get_user(amount, (long __user *)argp)) {
1740 if (amount > AX25_NOUID_BLOCK) {
1744 ax25_uid_policy = amount;
1752 if (!capable(CAP_NET_ADMIN)) {
1756 res = ax25_rt_ioctl(cmd, argp);
1759 case SIOCAX25CTLCON:
1760 if (!capable(CAP_NET_ADMIN)) {
1764 res = ax25_ctl_ioctl(cmd, argp);
1767 case SIOCAX25GETINFO:
1768 case SIOCAX25GETINFOOLD: {
1769 ax25_cb *ax25 = ax25_sk(sk);
1770 struct ax25_info_struct ax25_info;
1772 ax25_info.t1 = ax25->t1 / HZ;
1773 ax25_info.t2 = ax25->t2 / HZ;
1774 ax25_info.t3 = ax25->t3 / HZ;
1775 ax25_info.idle = ax25->idle / (60 * HZ);
1776 ax25_info.n2 = ax25->n2;
1777 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1778 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1779 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1780 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1781 ax25_info.n2count = ax25->n2count;
1782 ax25_info.state = ax25->state;
1783 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1784 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
1785 ax25_info.vs = ax25->vs;
1786 ax25_info.vr = ax25->vr;
1787 ax25_info.va = ax25->va;
1788 ax25_info.vs_max = ax25->vs; /* reserved */
1789 ax25_info.paclen = ax25->paclen;
1790 ax25_info.window = ax25->window;
1792 /* old structure? */
1793 if (cmd == SIOCAX25GETINFOOLD) {
1794 static int warned = 0;
1796 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1801 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1806 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1815 case SIOCAX25ADDFWD:
1816 case SIOCAX25DELFWD: {
1817 struct ax25_fwd_struct ax25_fwd;
1818 if (!capable(CAP_NET_ADMIN)) {
1822 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1826 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1832 case SIOCGIFDSTADDR:
1833 case SIOCSIFDSTADDR:
1834 case SIOCGIFBRDADDR:
1835 case SIOCSIFBRDADDR:
1836 case SIOCGIFNETMASK:
1837 case SIOCSIFNETMASK:
1852 #ifdef CONFIG_PROC_FS
1854 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1856 struct ax25_cb *ax25;
1857 struct hlist_node *node;
1860 spin_lock_bh(&ax25_list_lock);
1861 ax25_for_each(ax25, node, &ax25_list) {
1869 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1873 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1874 struct ax25_cb, ax25_node);
1877 static void ax25_info_stop(struct seq_file *seq, void *v)
1879 spin_unlock_bh(&ax25_list_lock);
1882 static int ax25_info_show(struct seq_file *seq, void *v)
1891 * 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
1894 seq_printf(seq, "%8.8lx %s %s%s ",
1896 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1897 ax2asc(buf, &ax25->source_addr),
1898 ax25->iamdigi? "*":"");
1899 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1901 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1902 seq_printf(seq, ",%s%s",
1903 ax2asc(buf, &ax25->digipeat->calls[k]),
1904 ax25->digipeat->repeated[k]? "*":"");
1907 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1909 ax25->vs, ax25->vr, ax25->va,
1910 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1911 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1912 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1913 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1914 ax25->idle / (60 * HZ),
1915 ax25->n2count, ax25->n2,
1920 if (ax25->sk != NULL) {
1921 bh_lock_sock(ax25->sk);
1922 seq_printf(seq," %d %d %ld\n",
1923 atomic_read(&ax25->sk->sk_wmem_alloc),
1924 atomic_read(&ax25->sk->sk_rmem_alloc),
1925 ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L);
1926 bh_unlock_sock(ax25->sk);
1928 seq_puts(seq, " * * *\n");
1933 static const struct seq_operations ax25_info_seqops = {
1934 .start = ax25_info_start,
1935 .next = ax25_info_next,
1936 .stop = ax25_info_stop,
1937 .show = ax25_info_show,
1940 static int ax25_info_open(struct inode *inode, struct file *file)
1942 return seq_open(file, &ax25_info_seqops);
1945 static const struct file_operations ax25_info_fops = {
1946 .owner = THIS_MODULE,
1947 .open = ax25_info_open,
1949 .llseek = seq_lseek,
1950 .release = seq_release,
1955 static struct net_proto_family ax25_family_ops = {
1957 .create = ax25_create,
1958 .owner = THIS_MODULE,
1961 static const struct proto_ops ax25_proto_ops = {
1963 .owner = THIS_MODULE,
1964 .release = ax25_release,
1966 .connect = ax25_connect,
1967 .socketpair = sock_no_socketpair,
1968 .accept = ax25_accept,
1969 .getname = ax25_getname,
1970 .poll = datagram_poll,
1971 .ioctl = ax25_ioctl,
1972 .listen = ax25_listen,
1973 .shutdown = ax25_shutdown,
1974 .setsockopt = ax25_setsockopt,
1975 .getsockopt = ax25_getsockopt,
1976 .sendmsg = ax25_sendmsg,
1977 .recvmsg = ax25_recvmsg,
1978 .mmap = sock_no_mmap,
1979 .sendpage = sock_no_sendpage,
1983 * Called by socket.c on kernel start up
1985 static struct packet_type ax25_packet_type = {
1986 .type = __constant_htons(ETH_P_AX25),
1987 .dev = NULL, /* All devices */
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);