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 /* Reject non AX.25 devices */
108 if (dev->type != ARPHRD_AX25)
113 ax25_dev_device_up(dev);
116 ax25_kill_by_device(dev);
117 ax25_rt_device_down(dev);
118 ax25_dev_device_down(dev);
128 * Add a socket to the bound sockets list.
130 void ax25_cb_add(ax25_cb *ax25)
132 spin_lock_bh(&ax25_list_lock);
134 hlist_add_head(&ax25->ax25_node, &ax25_list);
135 spin_unlock_bh(&ax25_list_lock);
139 * Find a socket that wants to accept the SABM we have just
142 struct sock *ax25_find_listener(ax25_address *addr, int digi,
143 struct net_device *dev, int type)
146 struct hlist_node *node;
148 spin_lock(&ax25_list_lock);
149 ax25_for_each(s, node, &ax25_list) {
150 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
152 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
153 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
154 /* If device is null we match any device */
155 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
157 spin_unlock(&ax25_list_lock);
162 spin_unlock(&ax25_list_lock);
168 * Find an AX.25 socket given both ends.
170 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
173 struct sock *sk = NULL;
175 struct hlist_node *node;
177 spin_lock(&ax25_list_lock);
178 ax25_for_each(s, node, &ax25_list) {
179 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
180 !ax25cmp(&s->dest_addr, dest_addr) &&
181 s->sk->sk_type == type) {
188 spin_unlock(&ax25_list_lock);
194 * Find an AX.25 control block given both ends. It will only pick up
195 * floating AX.25 control blocks or non Raw socket bound control blocks.
197 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
198 ax25_digi *digi, struct net_device *dev)
201 struct hlist_node *node;
203 spin_lock_bh(&ax25_list_lock);
204 ax25_for_each(s, node, &ax25_list) {
205 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
207 if (s->ax25_dev == NULL)
209 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
210 if (digi != NULL && digi->ndigi != 0) {
211 if (s->digipeat == NULL)
213 if (ax25digicmp(s->digipeat, digi) != 0)
216 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
220 spin_unlock_bh(&ax25_list_lock);
225 spin_unlock_bh(&ax25_list_lock);
230 EXPORT_SYMBOL(ax25_find_cb);
232 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
235 struct sk_buff *copy;
236 struct hlist_node *node;
238 spin_lock(&ax25_list_lock);
239 ax25_for_each(s, node, &ax25_list) {
240 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
241 s->sk->sk_type == SOCK_RAW &&
242 s->sk->sk_protocol == proto &&
243 s->ax25_dev->dev == skb->dev &&
244 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
245 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
247 if (sock_queue_rcv_skb(s->sk, copy) != 0)
251 spin_unlock(&ax25_list_lock);
257 void ax25_destroy_socket(ax25_cb *);
260 * Handler for deferred kills.
262 static void ax25_destroy_timer(unsigned long data)
264 ax25_cb *ax25=(ax25_cb *)data;
271 ax25_destroy_socket(ax25);
277 * This is called from user mode and the timers. Thus it protects itself
278 * against interrupt users but doesn't worry about being called during
279 * work. Once it is removed from the queue no interrupt or bottom half
280 * will touch it and we are (fairly 8-) ) safe.
282 void ax25_destroy_socket(ax25_cb *ax25)
288 ax25_stop_heartbeat(ax25);
289 ax25_stop_t1timer(ax25);
290 ax25_stop_t2timer(ax25);
291 ax25_stop_t3timer(ax25);
292 ax25_stop_idletimer(ax25);
294 ax25_clear_queues(ax25); /* Flush the queues */
296 if (ax25->sk != NULL) {
297 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
298 if (skb->sk != ax25->sk) {
299 /* A pending connection */
300 ax25_cb *sax25 = ax25_sk(skb->sk);
302 /* Queue the unaccepted socket for death */
303 sock_orphan(skb->sk);
305 ax25_start_heartbeat(sax25);
306 sax25->state = AX25_STATE_0;
311 skb_queue_purge(&ax25->sk->sk_write_queue);
314 if (ax25->sk != NULL) {
315 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
316 atomic_read(&ax25->sk->sk_rmem_alloc)) {
317 /* Defer: outstanding buffers */
318 init_timer(&ax25->dtimer);
319 ax25->dtimer.expires = jiffies + 2 * HZ;
320 ax25->dtimer.function = ax25_destroy_timer;
321 ax25->dtimer.data = (unsigned long)ax25;
322 add_timer(&ax25->dtimer);
324 struct sock *sk=ax25->sk;
334 * dl1bke 960311: set parameters for existing AX.25 connections,
335 * includes a KILL command to abort any connection.
336 * VERY useful for debugging ;-)
338 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
340 struct ax25_ctl_struct ax25_ctl;
346 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
349 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
352 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
355 digi.ndigi = ax25_ctl.digi_count;
356 for (k = 0; k < digi.ndigi; k++)
357 digi.calls[k] = ax25_ctl.digi_addr[k];
359 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
362 switch (ax25_ctl.cmd) {
364 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
365 #ifdef CONFIG_AX25_DAMA_SLAVE
366 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
369 ax25_disconnect(ax25, ENETRESET);
373 if (ax25->modulus == AX25_MODULUS) {
374 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
377 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
380 ax25->window = ax25_ctl.arg;
384 if (ax25_ctl.arg < 1)
386 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
387 ax25->t1 = ax25_ctl.arg * HZ;
391 if (ax25_ctl.arg < 1)
393 ax25->t2 = ax25_ctl.arg * HZ;
397 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
400 ax25->n2 = ax25_ctl.arg;
404 if (ax25_ctl.arg < 0)
406 ax25->t3 = ax25_ctl.arg * HZ;
410 if (ax25_ctl.arg < 0)
412 ax25->idle = ax25_ctl.arg * 60 * HZ;
416 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
418 ax25->paclen = ax25_ctl.arg;
428 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
430 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
431 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
432 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
433 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
434 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
435 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
436 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
437 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
439 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
440 ax25->modulus = AX25_EMODULUS;
441 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
443 ax25->modulus = AX25_MODULUS;
444 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
449 * Fill in a created AX.25 created control block with the default
450 * values for a particular device.
452 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
454 ax25->ax25_dev = ax25_dev;
456 if (ax25->ax25_dev != NULL) {
457 ax25_fillin_cb_from_dev(ax25, ax25_dev);
462 * No device, use kernel / AX.25 spec default values
464 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
465 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
466 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
467 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
468 ax25->n2 = AX25_DEF_N2;
469 ax25->paclen = AX25_DEF_PACLEN;
470 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
471 ax25->backoff = AX25_DEF_BACKOFF;
473 if (AX25_DEF_AXDEFMODE) {
474 ax25->modulus = AX25_EMODULUS;
475 ax25->window = AX25_DEF_EWINDOW;
477 ax25->modulus = AX25_MODULUS;
478 ax25->window = AX25_DEF_WINDOW;
483 * Create an empty AX.25 control block.
485 ax25_cb *ax25_create_cb(void)
489 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
492 atomic_set(&ax25->refcount, 1);
494 skb_queue_head_init(&ax25->write_queue);
495 skb_queue_head_init(&ax25->frag_queue);
496 skb_queue_head_init(&ax25->ack_queue);
497 skb_queue_head_init(&ax25->reseq_queue);
499 init_timer(&ax25->timer);
500 init_timer(&ax25->t1timer);
501 init_timer(&ax25->t2timer);
502 init_timer(&ax25->t3timer);
503 init_timer(&ax25->idletimer);
505 ax25_fillin_cb(ax25, NULL);
507 ax25->state = AX25_STATE_0;
513 * Handling for system calls applied via the various interfaces to an
517 static int ax25_setsockopt(struct socket *sock, int level, int optname,
518 char __user *optval, int optlen)
520 struct sock *sk = sock->sk;
522 struct net_device *dev;
523 char devname[IFNAMSIZ];
526 if (level != SOL_AX25)
529 if (optlen < sizeof(int))
532 if (get_user(opt, (int __user *)optval))
540 if (ax25->modulus == AX25_MODULUS) {
541 if (opt < 1 || opt > 7) {
546 if (opt < 1 || opt > 63) {
559 ax25->rtt = (opt * HZ) / 2;
572 if (opt < 1 || opt > 31) {
592 ax25->idle = opt * 60 * HZ;
596 if (opt < 0 || opt > 2) {
604 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
608 ax25->pidincl = opt ? 1 : 0;
612 ax25->iamdigi = opt ? 1 : 0;
616 if (opt < 16 || opt > 65535) {
623 case SO_BINDTODEVICE:
624 if (optlen > IFNAMSIZ)
626 if (copy_from_user(devname, optval, optlen)) {
631 dev = dev_get_by_name(devname);
637 if (sk->sk_type == SOCK_SEQPACKET &&
638 (sock->state != SS_UNCONNECTED ||
639 sk->sk_state == TCP_LISTEN)) {
640 res = -EADDRNOTAVAIL;
645 ax25->ax25_dev = ax25_dev_ax25dev(dev);
646 ax25_fillin_cb(ax25, ax25->ax25_dev);
657 static int ax25_getsockopt(struct socket *sock, int level, int optname,
658 char __user *optval, int __user *optlen)
660 struct sock *sk = sock->sk;
662 struct ax25_dev *ax25_dev;
663 char devname[IFNAMSIZ];
668 if (level != SOL_AX25)
671 if (get_user(maxlen, optlen))
677 valptr = (void *) &val;
678 length = min_t(unsigned int, maxlen, sizeof(int));
705 val = ax25->idle / (60 * HZ);
713 val = (ax25->modulus == AX25_EMODULUS);
728 case SO_BINDTODEVICE:
729 ax25_dev = ax25->ax25_dev;
731 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
732 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
733 length = strlen(devname) + 1;
739 valptr = (void *) devname;
748 if (put_user(length, optlen))
751 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
754 static int ax25_listen(struct socket *sock, int backlog)
756 struct sock *sk = sock->sk;
760 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
761 sk->sk_max_ack_backlog = backlog;
762 sk->sk_state = TCP_LISTEN;
774 * XXX: when creating ax25_sock we should update the .obj_size setting
777 static struct proto ax25_proto = {
779 .owner = THIS_MODULE,
780 .obj_size = sizeof(struct sock),
783 static int ax25_create(struct net *net, struct socket *sock, int protocol)
788 if (net != &init_net)
789 return -EAFNOSUPPORT;
791 switch (sock->type) {
793 if (protocol == 0 || protocol == PF_AX25)
794 protocol = AX25_P_TEXT;
800 case PF_AX25: /* For CLX */
801 protocol = AX25_P_TEXT;
814 return -ESOCKTNOSUPPORT;
815 #ifdef CONFIG_NETROM_MODULE
817 if (ax25_protocol_is_registered(AX25_P_NETROM))
818 return -ESOCKTNOSUPPORT;
820 #ifdef CONFIG_ROSE_MODULE
822 if (ax25_protocol_is_registered(AX25_P_ROSE))
823 return -ESOCKTNOSUPPORT;
833 return -ESOCKTNOSUPPORT;
836 if ((sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, 1)) == NULL)
839 ax25 = sk->sk_protinfo = ax25_create_cb();
845 sock_init_data(sock, sk);
847 sk->sk_destruct = ax25_free_sock;
848 sock->ops = &ax25_proto_ops;
849 sk->sk_protocol = protocol;
856 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
859 ax25_cb *ax25, *oax25;
861 if ((sk = sk_alloc(osk->sk_net, PF_AX25, GFP_ATOMIC, osk->sk_prot, 1)) == NULL)
864 if ((ax25 = ax25_create_cb()) == NULL) {
869 switch (osk->sk_type) {
880 sock_init_data(NULL, sk);
882 sk->sk_destruct = ax25_free_sock;
883 sk->sk_type = osk->sk_type;
884 sk->sk_socket = osk->sk_socket;
885 sk->sk_priority = osk->sk_priority;
886 sk->sk_protocol = osk->sk_protocol;
887 sk->sk_rcvbuf = osk->sk_rcvbuf;
888 sk->sk_sndbuf = osk->sk_sndbuf;
889 sk->sk_state = TCP_ESTABLISHED;
890 sk->sk_sleep = osk->sk_sleep;
891 sock_copy_flags(sk, osk);
893 oax25 = ax25_sk(osk);
895 ax25->modulus = oax25->modulus;
896 ax25->backoff = oax25->backoff;
897 ax25->pidincl = oax25->pidincl;
898 ax25->iamdigi = oax25->iamdigi;
899 ax25->rtt = oax25->rtt;
900 ax25->t1 = oax25->t1;
901 ax25->t2 = oax25->t2;
902 ax25->t3 = oax25->t3;
903 ax25->n2 = oax25->n2;
904 ax25->idle = oax25->idle;
905 ax25->paclen = oax25->paclen;
906 ax25->window = oax25->window;
908 ax25->ax25_dev = ax25_dev;
909 ax25->source_addr = oax25->source_addr;
911 if (oax25->digipeat != NULL) {
912 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
914 if (ax25->digipeat == NULL) {
921 sk->sk_protinfo = ax25;
927 static int ax25_release(struct socket *sock)
929 struct sock *sk = sock->sk;
940 if (sk->sk_type == SOCK_SEQPACKET) {
941 switch (ax25->state) {
944 ax25_disconnect(ax25, 0);
946 ax25_destroy_socket(ax25);
951 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
953 ax25_disconnect(ax25, 0);
955 ax25_destroy_socket(ax25);
960 ax25_clear_queues(ax25);
963 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
964 case AX25_PROTO_STD_SIMPLEX:
965 case AX25_PROTO_STD_DUPLEX:
966 ax25_send_control(ax25,
970 ax25_stop_t2timer(ax25);
971 ax25_stop_t3timer(ax25);
972 ax25_stop_idletimer(ax25);
974 #ifdef CONFIG_AX25_DAMA_SLAVE
975 case AX25_PROTO_DAMA_SLAVE:
976 ax25_stop_t3timer(ax25);
977 ax25_stop_idletimer(ax25);
981 ax25_calculate_t1(ax25);
982 ax25_start_t1timer(ax25);
983 ax25->state = AX25_STATE_2;
984 sk->sk_state = TCP_CLOSE;
985 sk->sk_shutdown |= SEND_SHUTDOWN;
986 sk->sk_state_change(sk);
987 sock_set_flag(sk, SOCK_DESTROY);
994 sk->sk_state = TCP_CLOSE;
995 sk->sk_shutdown |= SEND_SHUTDOWN;
996 sk->sk_state_change(sk);
997 ax25_destroy_socket(ax25);
1008 * We support a funny extension here so you can (as root) give any callsign
1009 * digipeated via a local address as source. This hack is obsolete now
1010 * that we've implemented support for SO_BINDTODEVICE. It is however small
1011 * and trivially backward compatible.
1013 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1015 struct sock *sk = sock->sk;
1016 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1017 ax25_dev *ax25_dev = NULL;
1018 ax25_uid_assoc *user;
1023 if (addr_len != sizeof(struct sockaddr_ax25) &&
1024 addr_len != sizeof(struct full_sockaddr_ax25)) {
1025 /* support for old structure may go away some time */
1026 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1027 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1031 printk(KERN_WARNING "ax25_bind(): %s uses old (6 digipeater) socket structure.\n",
1035 if (addr->fsa_ax25.sax25_family != AF_AX25)
1038 user = ax25_findbyuid(current->euid);
1043 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1046 call = addr->fsa_ax25.sax25_call;
1052 if (!sock_flag(sk, SOCK_ZAPPED)) {
1057 ax25->source_addr = call;
1060 * User already set interface with SO_BINDTODEVICE
1062 if (ax25->ax25_dev != NULL)
1065 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1066 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1067 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1068 err = -EADDRNOTAVAIL;
1072 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1073 err = -EADDRNOTAVAIL;
1078 if (ax25_dev != NULL)
1079 ax25_fillin_cb(ax25, ax25_dev);
1083 sock_reset_flag(sk, SOCK_ZAPPED);
1092 * FIXME: nonblock behaviour looks like it may have a bug.
1094 static int __must_check ax25_connect(struct socket *sock,
1095 struct sockaddr *uaddr, int addr_len, int flags)
1097 struct sock *sk = sock->sk;
1098 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1099 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1100 ax25_digi *digi = NULL;
1101 int ct = 0, err = 0;
1104 * some sanity checks. code further down depends on this
1107 if (addr_len == sizeof(struct sockaddr_ax25)) {
1108 /* support for this will go away in early 2.5.x */
1109 printk(KERN_WARNING "ax25_connect(): %s uses obsolete socket structure\n",
1112 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1113 /* support for old structure may go away some time */
1114 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1115 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1119 printk(KERN_WARNING "ax25_connect(): %s uses old (6 digipeater) socket structure.\n",
1123 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1128 /* deal with restarts */
1129 if (sock->state == SS_CONNECTING) {
1130 switch (sk->sk_state) {
1131 case TCP_SYN_SENT: /* still trying */
1135 case TCP_ESTABLISHED: /* connection established */
1136 sock->state = SS_CONNECTED;
1139 case TCP_CLOSE: /* connection refused */
1140 sock->state = SS_UNCONNECTED;
1141 err = -ECONNREFUSED;
1146 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1147 err = -EISCONN; /* No reconnect on a seqpacket socket */
1151 sk->sk_state = TCP_CLOSE;
1152 sock->state = SS_UNCONNECTED;
1154 kfree(ax25->digipeat);
1155 ax25->digipeat = NULL;
1158 * Handle digi-peaters to be used.
1160 if (addr_len > sizeof(struct sockaddr_ax25) &&
1161 fsa->fsa_ax25.sax25_ndigis != 0) {
1162 /* Valid number of digipeaters ? */
1163 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1168 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1173 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1174 digi->lastrepeat = -1;
1176 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1177 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1178 AX25_HBIT) && ax25->iamdigi) {
1179 digi->repeated[ct] = 1;
1180 digi->lastrepeat = ct;
1182 digi->repeated[ct] = 0;
1184 digi->calls[ct] = fsa->fsa_digipeater[ct];
1190 * Must bind first - autobinding in this may or may not work. If
1191 * the socket is already bound, check to see if the device has
1192 * been filled in, error if it hasn't.
1194 if (sock_flag(sk, SOCK_ZAPPED)) {
1195 /* check if we can remove this feature. It is broken. */
1196 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1198 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1203 ax25_fillin_cb(ax25, ax25->ax25_dev);
1206 if (ax25->ax25_dev == NULL) {
1208 err = -EHOSTUNREACH;
1213 if (sk->sk_type == SOCK_SEQPACKET &&
1214 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1215 ax25->ax25_dev->dev))) {
1217 err = -EADDRINUSE; /* Already such a connection */
1222 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1223 ax25->digipeat = digi;
1225 /* First the easy one */
1226 if (sk->sk_type != SOCK_SEQPACKET) {
1227 sock->state = SS_CONNECTED;
1228 sk->sk_state = TCP_ESTABLISHED;
1232 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1233 sock->state = SS_CONNECTING;
1234 sk->sk_state = TCP_SYN_SENT;
1236 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1237 case AX25_PROTO_STD_SIMPLEX:
1238 case AX25_PROTO_STD_DUPLEX:
1239 ax25_std_establish_data_link(ax25);
1242 #ifdef CONFIG_AX25_DAMA_SLAVE
1243 case AX25_PROTO_DAMA_SLAVE:
1244 ax25->modulus = AX25_MODULUS;
1245 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1246 if (ax25->ax25_dev->dama.slave)
1247 ax25_ds_establish_data_link(ax25);
1249 ax25_std_establish_data_link(ax25);
1254 ax25->state = AX25_STATE_1;
1256 ax25_start_heartbeat(ax25);
1259 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1264 if (sk->sk_state == TCP_SYN_SENT) {
1268 prepare_to_wait(sk->sk_sleep, &wait,
1269 TASK_INTERRUPTIBLE);
1270 if (sk->sk_state != TCP_SYN_SENT)
1272 if (!signal_pending(current)) {
1281 finish_wait(sk->sk_sleep, &wait);
1287 if (sk->sk_state != TCP_ESTABLISHED) {
1288 /* Not in ABM, not in WAIT_UA -> failed */
1289 sock->state = SS_UNCONNECTED;
1290 err = sock_error(sk); /* Always set at this point */
1294 sock->state = SS_CONNECTED;
1303 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1305 struct sk_buff *skb;
1311 if (sock->state != SS_UNCONNECTED)
1314 if ((sk = sock->sk) == NULL)
1318 if (sk->sk_type != SOCK_SEQPACKET) {
1323 if (sk->sk_state != TCP_LISTEN) {
1329 * The read queue this time is holding sockets ready to use
1330 * hooked into the SABM we saved
1333 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1334 skb = skb_dequeue(&sk->sk_receive_queue);
1338 if (flags & O_NONBLOCK) {
1342 if (!signal_pending(current)) {
1351 finish_wait(sk->sk_sleep, &wait);
1357 newsk->sk_socket = newsock;
1358 newsk->sk_sleep = &newsock->wait;
1360 /* Now attach up the new socket */
1362 sk->sk_ack_backlog--;
1363 newsock->sk = newsk;
1364 newsock->state = SS_CONNECTED;
1372 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1373 int *uaddr_len, int peer)
1375 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1376 struct sock *sk = sock->sk;
1377 unsigned char ndigi, i;
1385 if (sk->sk_state != TCP_ESTABLISHED) {
1390 fsa->fsa_ax25.sax25_family = AF_AX25;
1391 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1392 fsa->fsa_ax25.sax25_ndigis = 0;
1394 if (ax25->digipeat != NULL) {
1395 ndigi = ax25->digipeat->ndigi;
1396 fsa->fsa_ax25.sax25_ndigis = ndigi;
1397 for (i = 0; i < ndigi; i++)
1398 fsa->fsa_digipeater[i] =
1399 ax25->digipeat->calls[i];
1402 fsa->fsa_ax25.sax25_family = AF_AX25;
1403 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1404 fsa->fsa_ax25.sax25_ndigis = 1;
1405 if (ax25->ax25_dev != NULL) {
1406 memcpy(&fsa->fsa_digipeater[0],
1407 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1409 fsa->fsa_digipeater[0] = null_ax25_address;
1412 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1420 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1421 struct msghdr *msg, size_t len)
1423 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1424 struct sock *sk = sock->sk;
1425 struct sockaddr_ax25 sax;
1426 struct sk_buff *skb;
1427 ax25_digi dtmp, *dp;
1430 int lv, err, addr_len = msg->msg_namelen;
1432 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1438 if (sock_flag(sk, SOCK_ZAPPED)) {
1439 err = -EADDRNOTAVAIL;
1443 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1444 send_sig(SIGPIPE, current, 0);
1449 if (ax25->ax25_dev == NULL) {
1454 if (len > ax25->ax25_dev->dev->mtu) {
1460 if (usax->sax25_family != AF_AX25) {
1465 if (addr_len == sizeof(struct sockaddr_ax25)) {
1466 printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structure\n",
1469 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1470 /* support for old structure may go away some time */
1471 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1472 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1477 printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n",
1481 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1483 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1485 /* Valid number of digipeaters ? */
1486 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1491 dtmp.ndigi = usax->sax25_ndigis;
1493 while (ct < usax->sax25_ndigis) {
1494 dtmp.repeated[ct] = 0;
1495 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1499 dtmp.lastrepeat = 0;
1503 if (sk->sk_type == SOCK_SEQPACKET &&
1504 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1508 if (usax->sax25_ndigis == 0)
1514 * FIXME: 1003.1g - if the socket is like this because
1515 * it has become closed (not started closed) and is VC
1516 * we ought to SIGPIPE, EPIPE
1518 if (sk->sk_state != TCP_ESTABLISHED) {
1522 sax.sax25_family = AF_AX25;
1523 sax.sax25_call = ax25->dest_addr;
1524 dp = ax25->digipeat;
1527 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1529 /* Build a packet */
1530 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1532 /* Assume the worst case */
1533 size = len + ax25->ax25_dev->dev->hard_header_len;
1535 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1539 skb_reserve(skb, size - len);
1541 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1543 /* User data follows immediately after the AX.25 data */
1544 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1550 skb_reset_network_header(skb);
1552 /* Add the PID if one is not supplied by the user in the skb */
1554 *skb_push(skb, 1) = sk->sk_protocol;
1556 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1558 if (sk->sk_type == SOCK_SEQPACKET) {
1559 /* Connected mode sockets go via the LAPB machine */
1560 if (sk->sk_state != TCP_ESTABLISHED) {
1566 /* Shove it onto the queue and kick */
1567 ax25_output(ax25, ax25->paclen, skb);
1573 skb_push(skb, 1 + ax25_addr_size(dp));
1575 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1578 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1580 /* Build an AX.25 header */
1581 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1582 dp, AX25_COMMAND, AX25_MODULUS);
1584 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1586 skb_set_transport_header(skb, lv);
1588 SOCK_DEBUG(sk, "base=%p pos=%p\n",
1589 skb->data, skb_transport_header(skb));
1591 *skb_transport_header(skb) = AX25_UI;
1593 /* Datagram frames go straight out of the door as UI */
1594 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1604 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1605 struct msghdr *msg, size_t size, int flags)
1607 struct sock *sk = sock->sk;
1608 struct sk_buff *skb;
1614 * This works for seqpacket too. The receiver has ordered the
1615 * queue for us! We do one quick check first though
1617 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1622 /* Now we can treat all alike */
1623 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1624 flags & MSG_DONTWAIT, &err);
1628 if (!ax25_sk(sk)->pidincl)
1629 skb_pull(skb, 1); /* Remove PID */
1631 skb_reset_transport_header(skb);
1634 if (copied > size) {
1636 msg->msg_flags |= MSG_TRUNC;
1639 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1641 if (msg->msg_namelen != 0) {
1642 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1645 const unsigned char *mac = skb_mac_header(skb);
1647 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1649 sax->sax25_family = AF_AX25;
1650 /* We set this correctly, even though we may not let the
1651 application know the digi calls further down (because it
1652 did NOT ask to know them). This could get political... **/
1653 sax->sax25_ndigis = digi.ndigi;
1654 sax->sax25_call = src;
1656 if (sax->sax25_ndigis != 0) {
1658 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1660 for (ct = 0; ct < digi.ndigi; ct++)
1661 fsa->fsa_digipeater[ct] = digi.calls[ct];
1663 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1666 skb_free_datagram(sk, skb);
1675 static int ax25_shutdown(struct socket *sk, int how)
1677 /* FIXME - generate DM and RNR states */
1681 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1683 struct sock *sk = sock->sk;
1684 void __user *argp = (void __user *)arg;
1691 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1694 res = put_user(amount, (int __user *)argp);
1699 struct sk_buff *skb;
1701 /* These two are safe on a single CPU system as only user tasks fiddle here */
1702 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1704 res = put_user(amount, (int __user *) argp);
1709 res = sock_get_timestamp(sk, argp);
1713 res = sock_get_timestampns(sk, argp);
1716 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1717 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1718 case SIOCAX25GETUID: {
1719 struct sockaddr_ax25 sax25;
1720 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1724 res = ax25_uid_ioctl(cmd, &sax25);
1728 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1730 if (!capable(CAP_NET_ADMIN)) {
1734 if (get_user(amount, (long __user *)argp)) {
1738 if (amount > AX25_NOUID_BLOCK) {
1742 ax25_uid_policy = amount;
1750 if (!capable(CAP_NET_ADMIN)) {
1754 res = ax25_rt_ioctl(cmd, argp);
1757 case SIOCAX25CTLCON:
1758 if (!capable(CAP_NET_ADMIN)) {
1762 res = ax25_ctl_ioctl(cmd, argp);
1765 case SIOCAX25GETINFO:
1766 case SIOCAX25GETINFOOLD: {
1767 ax25_cb *ax25 = ax25_sk(sk);
1768 struct ax25_info_struct ax25_info;
1770 ax25_info.t1 = ax25->t1 / HZ;
1771 ax25_info.t2 = ax25->t2 / HZ;
1772 ax25_info.t3 = ax25->t3 / HZ;
1773 ax25_info.idle = ax25->idle / (60 * HZ);
1774 ax25_info.n2 = ax25->n2;
1775 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1776 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1777 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1778 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1779 ax25_info.n2count = ax25->n2count;
1780 ax25_info.state = ax25->state;
1781 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1782 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
1783 ax25_info.vs = ax25->vs;
1784 ax25_info.vr = ax25->vr;
1785 ax25_info.va = ax25->va;
1786 ax25_info.vs_max = ax25->vs; /* reserved */
1787 ax25_info.paclen = ax25->paclen;
1788 ax25_info.window = ax25->window;
1790 /* old structure? */
1791 if (cmd == SIOCAX25GETINFOOLD) {
1792 static int warned = 0;
1794 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1799 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1804 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1813 case SIOCAX25ADDFWD:
1814 case SIOCAX25DELFWD: {
1815 struct ax25_fwd_struct ax25_fwd;
1816 if (!capable(CAP_NET_ADMIN)) {
1820 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1824 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1830 case SIOCGIFDSTADDR:
1831 case SIOCSIFDSTADDR:
1832 case SIOCGIFBRDADDR:
1833 case SIOCSIFBRDADDR:
1834 case SIOCGIFNETMASK:
1835 case SIOCSIFNETMASK:
1850 #ifdef CONFIG_PROC_FS
1852 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1854 struct ax25_cb *ax25;
1855 struct hlist_node *node;
1858 spin_lock_bh(&ax25_list_lock);
1859 ax25_for_each(ax25, node, &ax25_list) {
1867 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1871 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1872 struct ax25_cb, ax25_node);
1875 static void ax25_info_stop(struct seq_file *seq, void *v)
1877 spin_unlock_bh(&ax25_list_lock);
1880 static int ax25_info_show(struct seq_file *seq, void *v)
1889 * magic dev src_addr dest_addr,digi1,digi2,.. st vs vr va t1 t1 t2 t2 t3 t3 idle idle n2 n2 rtt window paclen Snd-Q Rcv-Q inode
1892 seq_printf(seq, "%8.8lx %s %s%s ",
1894 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1895 ax2asc(buf, &ax25->source_addr),
1896 ax25->iamdigi? "*":"");
1897 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1899 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1900 seq_printf(seq, ",%s%s",
1901 ax2asc(buf, &ax25->digipeat->calls[k]),
1902 ax25->digipeat->repeated[k]? "*":"");
1905 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1907 ax25->vs, ax25->vr, ax25->va,
1908 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1909 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1910 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1911 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1912 ax25->idle / (60 * HZ),
1913 ax25->n2count, ax25->n2,
1918 if (ax25->sk != NULL) {
1919 bh_lock_sock(ax25->sk);
1920 seq_printf(seq," %d %d %ld\n",
1921 atomic_read(&ax25->sk->sk_wmem_alloc),
1922 atomic_read(&ax25->sk->sk_rmem_alloc),
1923 ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L);
1924 bh_unlock_sock(ax25->sk);
1926 seq_puts(seq, " * * *\n");
1931 static const struct seq_operations ax25_info_seqops = {
1932 .start = ax25_info_start,
1933 .next = ax25_info_next,
1934 .stop = ax25_info_stop,
1935 .show = ax25_info_show,
1938 static int ax25_info_open(struct inode *inode, struct file *file)
1940 return seq_open(file, &ax25_info_seqops);
1943 static const struct file_operations ax25_info_fops = {
1944 .owner = THIS_MODULE,
1945 .open = ax25_info_open,
1947 .llseek = seq_lseek,
1948 .release = seq_release,
1953 static struct net_proto_family ax25_family_ops = {
1955 .create = ax25_create,
1956 .owner = THIS_MODULE,
1959 static const struct proto_ops ax25_proto_ops = {
1961 .owner = THIS_MODULE,
1962 .release = ax25_release,
1964 .connect = ax25_connect,
1965 .socketpair = sock_no_socketpair,
1966 .accept = ax25_accept,
1967 .getname = ax25_getname,
1968 .poll = datagram_poll,
1969 .ioctl = ax25_ioctl,
1970 .listen = ax25_listen,
1971 .shutdown = ax25_shutdown,
1972 .setsockopt = ax25_setsockopt,
1973 .getsockopt = ax25_getsockopt,
1974 .sendmsg = ax25_sendmsg,
1975 .recvmsg = ax25_recvmsg,
1976 .mmap = sock_no_mmap,
1977 .sendpage = sock_no_sendpage,
1981 * Called by socket.c on kernel start up
1983 static struct packet_type ax25_packet_type = {
1984 .type = __constant_htons(ETH_P_AX25),
1985 .dev = NULL, /* All devices */
1986 .func = ax25_kiss_rcv,
1989 static struct notifier_block ax25_dev_notifier = {
1990 .notifier_call =ax25_device_event,
1993 static int __init ax25_init(void)
1995 int rc = proto_register(&ax25_proto, 0);
2000 sock_register(&ax25_family_ops);
2001 dev_add_pack(&ax25_packet_type);
2002 register_netdevice_notifier(&ax25_dev_notifier);
2003 ax25_register_sysctl();
2005 proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
2006 proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
2007 proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
2011 module_init(ax25_init);
2014 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2015 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2016 MODULE_LICENSE("GPL");
2017 MODULE_ALIAS_NETPROTO(PF_AX25);
2019 static void __exit ax25_exit(void)
2021 proc_net_remove(&init_net, "ax25_route");
2022 proc_net_remove(&init_net, "ax25");
2023 proc_net_remove(&init_net, "ax25_calls");
2028 ax25_unregister_sysctl();
2029 unregister_netdevice_notifier(&ax25_dev_notifier);
2031 dev_remove_pack(&ax25_packet_type);
2033 sock_unregister(PF_AX25);
2034 proto_unregister(&ax25_proto);
2036 module_exit(ax25_exit);