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/config.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/smp_lock.h>
27 #include <linux/sockios.h>
28 #include <linux/net.h>
30 #include <linux/inet.h>
31 #include <linux/netdevice.h>
32 #include <linux/if_arp.h>
33 #include <linux/skbuff.h>
35 #include <asm/uaccess.h>
36 #include <asm/system.h>
37 #include <linux/fcntl.h>
38 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
40 #include <linux/interrupt.h>
41 #include <linux/notifier.h>
42 #include <linux/proc_fs.h>
43 #include <linux/stat.h>
44 #include <linux/netfilter.h>
45 #include <linux/sysctl.h>
46 #include <linux/init.h>
47 #include <linux/spinlock.h>
54 HLIST_HEAD(ax25_list);
55 spinlock_t ax25_list_lock = SPIN_LOCK_UNLOCKED;
57 static 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_bh(&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_bh(&ax25_list_lock);
162 spin_unlock_bh(&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_bh(&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) {
183 /* XXX Sleeps with spinlock held, use refcounts instead. XXX */
189 spin_unlock_bh(&ax25_list_lock);
195 * Find an AX.25 control block given both ends. It will only pick up
196 * floating AX.25 control blocks or non Raw socket bound control blocks.
198 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
199 ax25_digi *digi, struct net_device *dev)
202 struct hlist_node *node;
204 spin_lock_bh(&ax25_list_lock);
205 ax25_for_each(s, node, &ax25_list) {
206 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
208 if (s->ax25_dev == NULL)
210 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
211 if (digi != NULL && digi->ndigi != 0) {
212 if (s->digipeat == NULL)
214 if (ax25digicmp(s->digipeat, digi) != 0)
217 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
221 spin_unlock_bh(&ax25_list_lock);
226 spin_unlock_bh(&ax25_list_lock);
231 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
234 struct sk_buff *copy;
235 struct hlist_node *node;
237 spin_lock_bh(&ax25_list_lock);
238 ax25_for_each(s, node, &ax25_list) {
239 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
240 s->sk->sk_type == SOCK_RAW &&
241 s->sk->sk_protocol == proto &&
242 s->ax25_dev->dev == skb->dev &&
243 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
244 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
246 if (sock_queue_rcv_skb(s->sk, copy) != 0)
250 spin_unlock_bh(&ax25_list_lock);
256 void ax25_destroy_socket(ax25_cb *);
259 * Handler for deferred kills.
261 static void ax25_destroy_timer(unsigned long data)
263 ax25_cb *ax25=(ax25_cb *)data;
270 ax25_destroy_socket(ax25);
276 * This is called from user mode and the timers. Thus it protects itself
277 * against interrupt users but doesn't worry about being called during
278 * work. Once it is removed from the queue no interrupt or bottom half
279 * will touch it and we are (fairly 8-) ) safe.
281 void ax25_destroy_socket(ax25_cb *ax25)
287 ax25_stop_heartbeat(ax25);
288 ax25_stop_t1timer(ax25);
289 ax25_stop_t2timer(ax25);
290 ax25_stop_t3timer(ax25);
291 ax25_stop_idletimer(ax25);
293 ax25_clear_queues(ax25); /* Flush the queues */
295 if (ax25->sk != NULL) {
296 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
297 if (skb->sk != ax25->sk) {
298 /* A pending connection */
299 ax25_cb *sax25 = ax25_sk(skb->sk);
301 /* Queue the unaccepted socket for death */
302 sock_orphan(skb->sk);
304 ax25_start_heartbeat(sax25);
305 sax25->state = AX25_STATE_0;
310 while ((skb = skb_dequeue(&ax25->sk->sk_write_queue)) != NULL) {
315 if (ax25->sk != NULL) {
316 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
317 atomic_read(&ax25->sk->sk_rmem_alloc)) {
318 /* Defer: outstanding buffers */
319 init_timer(&ax25->dtimer);
320 ax25->dtimer.expires = jiffies + 2 * HZ;
321 ax25->dtimer.function = ax25_destroy_timer;
322 ax25->dtimer.data = (unsigned long)ax25;
323 add_timer(&ax25->dtimer);
325 struct sock *sk=ax25->sk;
335 * dl1bke 960311: set parameters for existing AX.25 connections,
336 * includes a KILL command to abort any connection.
337 * VERY useful for debugging ;-)
339 static int ax25_ctl_ioctl(const unsigned int cmd, void *arg)
341 struct ax25_ctl_struct ax25_ctl;
347 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
350 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
353 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
356 digi.ndigi = ax25_ctl.digi_count;
357 for (k = 0; k < digi.ndigi; k++)
358 digi.calls[k] = ax25_ctl.digi_addr[k];
360 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
363 switch (ax25_ctl.cmd) {
365 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
366 #ifdef CONFIG_AX25_DAMA_SLAVE
367 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
370 ax25_disconnect(ax25, ENETRESET);
374 if (ax25->modulus == AX25_MODULUS) {
375 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
378 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
381 ax25->window = ax25_ctl.arg;
385 if (ax25_ctl.arg < 1)
387 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
388 ax25->t1 = ax25_ctl.arg * HZ;
392 if (ax25_ctl.arg < 1)
394 ax25->t2 = ax25_ctl.arg * HZ;
398 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
401 ax25->n2 = ax25_ctl.arg;
405 if (ax25_ctl.arg < 0)
407 ax25->t3 = ax25_ctl.arg * HZ;
411 if (ax25_ctl.arg < 0)
413 ax25->idle = ax25_ctl.arg * 60 * HZ;
417 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
419 ax25->paclen = ax25_ctl.arg;
430 * Fill in a created AX.25 created control block with the default
431 * values for a particular device.
433 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
435 ax25->ax25_dev = ax25_dev;
437 if (ax25->ax25_dev != NULL) {
438 ax25->rtt = ax25_dev->values[AX25_VALUES_T1] / 2;
439 ax25->t1 = ax25_dev->values[AX25_VALUES_T1];
440 ax25->t2 = ax25_dev->values[AX25_VALUES_T2];
441 ax25->t3 = ax25_dev->values[AX25_VALUES_T3];
442 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
443 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
444 ax25->idle = ax25_dev->values[AX25_VALUES_IDLE];
445 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
447 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
448 ax25->modulus = AX25_EMODULUS;
449 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
451 ax25->modulus = AX25_MODULUS;
452 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
455 ax25->rtt = AX25_DEF_T1 / 2;
456 ax25->t1 = AX25_DEF_T1;
457 ax25->t2 = AX25_DEF_T2;
458 ax25->t3 = AX25_DEF_T3;
459 ax25->n2 = AX25_DEF_N2;
460 ax25->paclen = AX25_DEF_PACLEN;
461 ax25->idle = AX25_DEF_IDLE;
462 ax25->backoff = AX25_DEF_BACKOFF;
464 if (AX25_DEF_AXDEFMODE) {
465 ax25->modulus = AX25_EMODULUS;
466 ax25->window = AX25_DEF_EWINDOW;
468 ax25->modulus = AX25_MODULUS;
469 ax25->window = AX25_DEF_WINDOW;
475 * Create an empty AX.25 control block.
477 ax25_cb *ax25_create_cb(void)
481 if ((ax25 = kmalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
484 memset(ax25, 0x00, sizeof(*ax25));
485 atomic_set(&ax25->refcount, 1);
487 skb_queue_head_init(&ax25->write_queue);
488 skb_queue_head_init(&ax25->frag_queue);
489 skb_queue_head_init(&ax25->ack_queue);
490 skb_queue_head_init(&ax25->reseq_queue);
492 init_timer(&ax25->timer);
493 init_timer(&ax25->t1timer);
494 init_timer(&ax25->t2timer);
495 init_timer(&ax25->t3timer);
496 init_timer(&ax25->idletimer);
498 ax25_fillin_cb(ax25, NULL);
500 ax25->state = AX25_STATE_0;
506 * Handling for system calls applied via the various interfaces to an
510 static int ax25_setsockopt(struct socket *sock, int level, int optname,
511 char __user *optval, int optlen)
513 struct sock *sk = sock->sk;
515 struct net_device *dev;
516 char devname[IFNAMSIZ];
519 if (level != SOL_AX25)
522 if (optlen < sizeof(int))
525 if (get_user(opt, (int __user *)optval))
533 if (ax25->modulus == AX25_MODULUS) {
534 if (opt < 1 || opt > 7) {
539 if (opt < 1 || opt > 63) {
552 ax25->rtt = (opt * HZ) / 2;
565 if (opt < 1 || opt > 31) {
585 ax25->idle = opt * 60 * HZ;
589 if (opt < 0 || opt > 2) {
597 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
601 ax25->pidincl = opt ? 1 : 0;
605 ax25->iamdigi = opt ? 1 : 0;
609 if (opt < 16 || opt > 65535) {
616 case SO_BINDTODEVICE:
617 if (optlen > IFNAMSIZ)
619 if (copy_from_user(devname, optval, optlen)) {
624 dev = dev_get_by_name(devname);
630 if (sk->sk_type == SOCK_SEQPACKET &&
631 (sock->state != SS_UNCONNECTED ||
632 sk->sk_state == TCP_LISTEN)) {
633 res = -EADDRNOTAVAIL;
638 ax25->ax25_dev = ax25_dev_ax25dev(dev);
639 ax25_fillin_cb(ax25, ax25->ax25_dev);
650 static int ax25_getsockopt(struct socket *sock, int level, int optname,
651 char __user *optval, int __user *optlen)
653 struct sock *sk = sock->sk;
655 struct ax25_dev *ax25_dev;
656 char devname[IFNAMSIZ];
661 if (level != SOL_AX25)
664 if (get_user(maxlen, optlen))
670 valptr = (void *) &val;
671 length = min_t(unsigned int, maxlen, sizeof(int));
698 val = ax25->idle / (60 * HZ);
706 val = (ax25->modulus == AX25_EMODULUS);
721 case SO_BINDTODEVICE:
722 ax25_dev = ax25->ax25_dev;
724 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
725 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
726 length = strlen(devname) + 1;
732 valptr = (void *) devname;
741 if (put_user(length, optlen))
744 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
747 static int ax25_listen(struct socket *sock, int backlog)
749 struct sock *sk = sock->sk;
753 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
754 sk->sk_max_ack_backlog = backlog;
755 sk->sk_state = TCP_LISTEN;
766 int ax25_create(struct socket *sock, int protocol)
771 switch (sock->type) {
773 if (protocol == 0 || protocol == PF_AX25)
774 protocol = AX25_P_TEXT;
780 case PF_AX25: /* For CLX */
781 protocol = AX25_P_TEXT;
794 return -ESOCKTNOSUPPORT;
795 #ifdef CONFIG_NETROM_MODULE
797 if (ax25_protocol_is_registered(AX25_P_NETROM))
798 return -ESOCKTNOSUPPORT;
800 #ifdef CONFIG_ROSE_MODULE
802 if (ax25_protocol_is_registered(AX25_P_ROSE))
803 return -ESOCKTNOSUPPORT;
813 return -ESOCKTNOSUPPORT;
816 if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, 1, NULL)) == NULL)
819 ax25 = sk->sk_protinfo = ax25_create_cb();
825 sock_init_data(sock, sk);
826 sk_set_owner(sk, THIS_MODULE);
828 sk->sk_destruct = ax25_free_sock;
829 sock->ops = &ax25_proto_ops;
830 sk->sk_protocol = protocol;
837 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
840 ax25_cb *ax25, *oax25;
842 if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, 1, NULL)) == NULL)
845 if ((ax25 = ax25_create_cb()) == NULL) {
850 switch (osk->sk_type) {
861 sock_init_data(NULL, sk);
862 sk_set_owner(sk, THIS_MODULE);
864 sk->sk_destruct = ax25_free_sock;
865 sk->sk_type = osk->sk_type;
866 sk->sk_socket = osk->sk_socket;
867 sk->sk_priority = osk->sk_priority;
868 sk->sk_protocol = osk->sk_protocol;
869 sk->sk_rcvbuf = osk->sk_rcvbuf;
870 sk->sk_sndbuf = osk->sk_sndbuf;
871 sk->sk_debug = osk->sk_debug;
872 sk->sk_state = TCP_ESTABLISHED;
873 sk->sk_sleep = osk->sk_sleep;
874 sk->sk_zapped = osk->sk_zapped;
876 oax25 = ax25_sk(osk);
878 ax25->modulus = oax25->modulus;
879 ax25->backoff = oax25->backoff;
880 ax25->pidincl = oax25->pidincl;
881 ax25->iamdigi = oax25->iamdigi;
882 ax25->rtt = oax25->rtt;
883 ax25->t1 = oax25->t1;
884 ax25->t2 = oax25->t2;
885 ax25->t3 = oax25->t3;
886 ax25->n2 = oax25->n2;
887 ax25->idle = oax25->idle;
888 ax25->paclen = oax25->paclen;
889 ax25->window = oax25->window;
891 ax25->ax25_dev = ax25_dev;
892 ax25->source_addr = oax25->source_addr;
894 if (oax25->digipeat != NULL) {
895 if ((ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
901 memcpy(ax25->digipeat, oax25->digipeat, sizeof(ax25_digi));
904 sk->sk_protinfo = ax25;
910 static int ax25_release(struct socket *sock)
912 struct sock *sk = sock->sk;
923 if (sk->sk_type == SOCK_SEQPACKET) {
924 switch (ax25->state) {
927 ax25_disconnect(ax25, 0);
929 ax25_destroy_socket(ax25);
934 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
936 ax25_disconnect(ax25, 0);
938 ax25_destroy_socket(ax25);
943 ax25_clear_queues(ax25);
946 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
947 case AX25_PROTO_STD_SIMPLEX:
948 case AX25_PROTO_STD_DUPLEX:
949 ax25_send_control(ax25,
953 ax25_stop_t2timer(ax25);
954 ax25_stop_t3timer(ax25);
955 ax25_stop_idletimer(ax25);
957 #ifdef CONFIG_AX25_DAMA_SLAVE
958 case AX25_PROTO_DAMA_SLAVE:
959 ax25_stop_t3timer(ax25);
960 ax25_stop_idletimer(ax25);
964 ax25_calculate_t1(ax25);
965 ax25_start_t1timer(ax25);
966 ax25->state = AX25_STATE_2;
967 sk->sk_state = TCP_CLOSE;
968 sk->sk_shutdown |= SEND_SHUTDOWN;
969 sk->sk_state_change(sk);
970 sock_set_flag(sk, SOCK_DESTROY);
977 sk->sk_state = TCP_CLOSE;
978 sk->sk_shutdown |= SEND_SHUTDOWN;
979 sk->sk_state_change(sk);
980 ax25_destroy_socket(ax25);
991 * We support a funny extension here so you can (as root) give any callsign
992 * digipeated via a local address as source. This hack is obsolete now
993 * that we've implemented support for SO_BINDTODEVICE. It is however small
994 * and trivially backward compatible.
996 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
998 struct sock *sk = sock->sk;
999 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1000 ax25_dev *ax25_dev = NULL;
1005 if (addr_len != sizeof(struct sockaddr_ax25) &&
1006 addr_len != sizeof(struct full_sockaddr_ax25)) {
1007 /* support for old structure may go away some time */
1008 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1009 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1013 printk(KERN_WARNING "ax25_bind(): %s uses old (6 digipeater) socket structure.\n",
1017 if (addr->fsa_ax25.sax25_family != AF_AX25)
1020 call = ax25_findbyuid(current->euid);
1021 if (call == NULL && ax25_uid_policy && !capable(CAP_NET_ADMIN)) {
1028 if (!sk->sk_zapped) {
1034 ax25->source_addr = addr->fsa_ax25.sax25_call;
1036 ax25->source_addr = *call;
1039 * User already set interface with SO_BINDTODEVICE
1041 if (ax25->ax25_dev != NULL)
1044 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1045 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1046 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1047 err = -EADDRNOTAVAIL;
1051 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1052 err = -EADDRNOTAVAIL;
1057 if (ax25_dev != NULL)
1058 ax25_fillin_cb(ax25, ax25_dev);
1071 * FIXME: nonblock behaviour looks like it may have a bug.
1073 static int ax25_connect(struct socket *sock, struct sockaddr *uaddr,
1074 int addr_len, int flags)
1076 struct sock *sk = sock->sk;
1077 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1078 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1079 ax25_digi *digi = NULL;
1080 int ct = 0, err = 0;
1083 * some sanity checks. code further down depends on this
1086 if (addr_len == sizeof(struct sockaddr_ax25)) {
1087 /* support for this will go away in early 2.5.x */
1088 printk(KERN_WARNING "ax25_connect(): %s uses obsolete socket structure\n",
1091 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1092 /* support for old structure may go away some time */
1093 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1094 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1098 printk(KERN_WARNING "ax25_connect(): %s uses old (6 digipeater) socket structure.\n",
1102 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1107 /* deal with restarts */
1108 if (sock->state == SS_CONNECTING) {
1109 switch (sk->sk_state) {
1110 case TCP_SYN_SENT: /* still trying */
1114 case TCP_ESTABLISHED: /* connection established */
1115 sock->state = SS_CONNECTED;
1118 case TCP_CLOSE: /* connection refused */
1119 sock->state = SS_UNCONNECTED;
1120 err = -ECONNREFUSED;
1125 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1126 err = -EISCONN; /* No reconnect on a seqpacket socket */
1130 sk->sk_state = TCP_CLOSE;
1131 sock->state = SS_UNCONNECTED;
1133 if (ax25->digipeat != NULL) {
1134 kfree(ax25->digipeat);
1135 ax25->digipeat = NULL;
1139 * Handle digi-peaters to be used.
1141 if (addr_len > sizeof(struct sockaddr_ax25) &&
1142 fsa->fsa_ax25.sax25_ndigis != 0) {
1143 /* Valid number of digipeaters ? */
1144 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1149 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1154 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1155 digi->lastrepeat = -1;
1157 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1158 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1159 AX25_HBIT) && ax25->iamdigi) {
1160 digi->repeated[ct] = 1;
1161 digi->lastrepeat = ct;
1163 digi->repeated[ct] = 0;
1165 digi->calls[ct] = fsa->fsa_digipeater[ct];
1171 * Must bind first - autobinding in this may or may not work. If
1172 * the socket is already bound, check to see if the device has
1173 * been filled in, error if it hasn't.
1175 if (sk->sk_zapped) {
1176 /* check if we can remove this feature. It is broken. */
1177 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1179 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0)
1182 ax25_fillin_cb(ax25, ax25->ax25_dev);
1185 if (ax25->ax25_dev == NULL) {
1186 err = -EHOSTUNREACH;
1191 if (sk->sk_type == SOCK_SEQPACKET &&
1192 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1193 ax25->ax25_dev->dev))) {
1196 err = -EADDRINUSE; /* Already such a connection */
1201 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1202 ax25->digipeat = digi;
1204 /* First the easy one */
1205 if (sk->sk_type != SOCK_SEQPACKET) {
1206 sock->state = SS_CONNECTED;
1207 sk->sk_state = TCP_ESTABLISHED;
1211 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1212 sock->state = SS_CONNECTING;
1213 sk->sk_state = TCP_SYN_SENT;
1215 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1216 case AX25_PROTO_STD_SIMPLEX:
1217 case AX25_PROTO_STD_DUPLEX:
1218 ax25_std_establish_data_link(ax25);
1221 #ifdef CONFIG_AX25_DAMA_SLAVE
1222 case AX25_PROTO_DAMA_SLAVE:
1223 ax25->modulus = AX25_MODULUS;
1224 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1225 if (ax25->ax25_dev->dama.slave)
1226 ax25_ds_establish_data_link(ax25);
1228 ax25_std_establish_data_link(ax25);
1233 ax25->state = AX25_STATE_1;
1235 ax25_start_heartbeat(ax25);
1238 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1243 if (sk->sk_state == TCP_SYN_SENT) {
1244 struct task_struct *tsk = current;
1245 DECLARE_WAITQUEUE(wait, tsk);
1247 add_wait_queue(sk->sk_sleep, &wait);
1249 if (sk->sk_state != TCP_SYN_SENT)
1251 set_current_state(TASK_INTERRUPTIBLE);
1253 if (!signal_pending(tsk)) {
1258 current->state = TASK_RUNNING;
1259 remove_wait_queue(sk->sk_sleep, &wait);
1260 return -ERESTARTSYS;
1262 current->state = TASK_RUNNING;
1263 remove_wait_queue(sk->sk_sleep, &wait);
1266 if (sk->sk_state != TCP_ESTABLISHED) {
1267 /* Not in ABM, not in WAIT_UA -> failed */
1268 sock->state = SS_UNCONNECTED;
1269 err = sock_error(sk); /* Always set at this point */
1273 sock->state = SS_CONNECTED;
1283 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1285 struct task_struct *tsk = current;
1286 DECLARE_WAITQUEUE(wait, tsk);
1287 struct sk_buff *skb;
1292 if (sock->state != SS_UNCONNECTED)
1295 if ((sk = sock->sk) == NULL)
1299 if (sk->sk_type != SOCK_SEQPACKET) {
1304 if (sk->sk_state != TCP_LISTEN) {
1310 * The read queue this time is holding sockets ready to use
1311 * hooked into the SABM we saved
1313 add_wait_queue(sk->sk_sleep, &wait);
1315 skb = skb_dequeue(&sk->sk_receive_queue);
1320 current->state = TASK_INTERRUPTIBLE;
1321 if (flags & O_NONBLOCK) {
1322 current->state = TASK_RUNNING;
1323 remove_wait_queue(sk->sk_sleep, &wait);
1324 return -EWOULDBLOCK;
1326 if (!signal_pending(tsk)) {
1331 current->state = TASK_RUNNING;
1332 remove_wait_queue(sk->sk_sleep, &wait);
1333 return -ERESTARTSYS;
1335 current->state = TASK_RUNNING;
1336 remove_wait_queue(sk->sk_sleep, &wait);
1339 newsk->sk_pair = NULL;
1340 newsk->sk_socket = newsock;
1341 newsk->sk_sleep = &newsock->wait;
1343 /* Now attach up the new socket */
1345 sk->sk_ack_backlog--;
1346 newsock->sk = newsk;
1347 newsock->state = SS_CONNECTED;
1355 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1356 int *uaddr_len, int peer)
1358 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1359 struct sock *sk = sock->sk;
1360 unsigned char ndigi, i;
1368 if (sk->sk_state != TCP_ESTABLISHED) {
1373 fsa->fsa_ax25.sax25_family = AF_AX25;
1374 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1375 fsa->fsa_ax25.sax25_ndigis = 0;
1377 if (ax25->digipeat != NULL) {
1378 ndigi = ax25->digipeat->ndigi;
1379 fsa->fsa_ax25.sax25_ndigis = ndigi;
1380 for (i = 0; i < ndigi; i++)
1381 fsa->fsa_digipeater[i] =
1382 ax25->digipeat->calls[i];
1385 fsa->fsa_ax25.sax25_family = AF_AX25;
1386 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1387 fsa->fsa_ax25.sax25_ndigis = 1;
1388 if (ax25->ax25_dev != NULL) {
1389 memcpy(&fsa->fsa_digipeater[0],
1390 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1392 fsa->fsa_digipeater[0] = null_ax25_address;
1395 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1403 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1404 struct msghdr *msg, size_t len)
1406 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1407 struct sock *sk = sock->sk;
1408 struct sockaddr_ax25 sax;
1409 struct sk_buff *skb;
1410 ax25_digi dtmp, *dp;
1411 unsigned char *asmptr;
1414 int lv, err, addr_len = msg->msg_namelen;
1416 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR)) {
1423 if (sk->sk_zapped) {
1424 err = -EADDRNOTAVAIL;
1428 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1429 send_sig(SIGPIPE, current, 0);
1434 if (ax25->ax25_dev == NULL) {
1439 if (len > ax25->ax25_dev->dev->mtu) {
1445 if (usax->sax25_family != AF_AX25) {
1450 if (addr_len == sizeof(struct sockaddr_ax25)) {
1451 printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structure\n",
1454 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1455 /* support for old structure may go away some time */
1456 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1457 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1462 printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n",
1466 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1468 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1470 /* Valid number of digipeaters ? */
1471 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1476 dtmp.ndigi = usax->sax25_ndigis;
1478 while (ct < usax->sax25_ndigis) {
1479 dtmp.repeated[ct] = 0;
1480 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1484 dtmp.lastrepeat = 0;
1488 if (sk->sk_type == SOCK_SEQPACKET &&
1489 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1493 if (usax->sax25_ndigis == 0)
1499 * FIXME: 1003.1g - if the socket is like this because
1500 * it has become closed (not started closed) and is VC
1501 * we ought to SIGPIPE, EPIPE
1503 if (sk->sk_state != TCP_ESTABLISHED) {
1507 sax.sax25_family = AF_AX25;
1508 sax.sax25_call = ax25->dest_addr;
1509 dp = ax25->digipeat;
1512 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1514 /* Build a packet */
1515 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1517 /* Assume the worst case */
1518 size = len + ax25->ax25_dev->dev->hard_header_len;
1520 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1524 skb_reserve(skb, size - len);
1526 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1528 /* User data follows immediately after the AX.25 data */
1529 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1535 skb->nh.raw = skb->data;
1537 /* Add the PID if one is not supplied by the user in the skb */
1538 if (!ax25->pidincl) {
1539 asmptr = skb_push(skb, 1);
1540 *asmptr = sk->sk_protocol;
1543 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1545 if (sk->sk_type == SOCK_SEQPACKET) {
1546 /* Connected mode sockets go via the LAPB machine */
1547 if (sk->sk_state != TCP_ESTABLISHED) {
1553 /* Shove it onto the queue and kick */
1554 ax25_output(ax25, ax25->paclen, skb);
1560 asmptr = skb_push(skb, 1 + ax25_addr_size(dp));
1562 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1565 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1567 /* Build an AX.25 header */
1568 asmptr += (lv = ax25_addr_build(asmptr, &ax25->source_addr,
1569 &sax.sax25_call, dp,
1570 AX25_COMMAND, AX25_MODULUS));
1572 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1574 skb->h.raw = asmptr;
1576 SOCK_DEBUG(sk, "base=%p pos=%p\n", skb->data, asmptr);
1580 /* Datagram frames go straight out of the door as UI */
1581 skb->dev = ax25->ax25_dev->dev;
1583 ax25_queue_xmit(skb);
1593 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1594 struct msghdr *msg, size_t size, int flags)
1596 struct sock *sk = sock->sk;
1597 struct sk_buff *skb;
1603 * This works for seqpacket too. The receiver has ordered the
1604 * queue for us! We do one quick check first though
1606 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1611 /* Now we can treat all alike */
1612 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1613 flags & MSG_DONTWAIT, &err);
1617 if (!ax25_sk(sk)->pidincl)
1618 skb_pull(skb, 1); /* Remove PID */
1620 skb->h.raw = skb->data;
1623 if (copied > size) {
1625 msg->msg_flags |= MSG_TRUNC;
1628 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1630 if (msg->msg_namelen != 0) {
1631 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1635 ax25_addr_parse(skb->mac.raw+1, skb->data-skb->mac.raw-1, &src, NULL, &digi, NULL, NULL);
1637 sax->sax25_family = AF_AX25;
1638 /* We set this correctly, even though we may not let the
1639 application know the digi calls further down (because it
1640 did NOT ask to know them). This could get political... **/
1641 sax->sax25_ndigis = digi.ndigi;
1642 sax->sax25_call = src;
1644 if (sax->sax25_ndigis != 0) {
1646 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1648 for (ct = 0; ct < digi.ndigi; ct++)
1649 fsa->fsa_digipeater[ct] = digi.calls[ct];
1651 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1654 skb_free_datagram(sk, skb);
1663 static int ax25_shutdown(struct socket *sk, int how)
1665 /* FIXME - generate DM and RNR states */
1669 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1671 struct sock *sk = sock->sk;
1678 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1681 res = put_user(amount, (int *)arg);
1686 struct sk_buff *skb;
1688 /* These two are safe on a single CPU system as only user tasks fiddle here */
1689 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1691 res = put_user(amount, (int *)arg);
1697 res = sock_get_timestamp(sk, (struct timeval __user *)arg);
1703 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1704 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1705 case SIOCAX25GETUID: {
1706 struct sockaddr_ax25 sax25;
1707 if (copy_from_user(&sax25, (void *)arg, sizeof(sax25))) {
1711 res = ax25_uid_ioctl(cmd, &sax25);
1715 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1717 if (!capable(CAP_NET_ADMIN)) {
1721 if (get_user(amount, (long *)arg)) {
1725 if (amount > AX25_NOUID_BLOCK) {
1729 ax25_uid_policy = amount;
1737 if (!capable(CAP_NET_ADMIN)) {
1741 res = ax25_rt_ioctl(cmd, (void *)arg);
1744 case SIOCAX25CTLCON:
1745 if (!capable(CAP_NET_ADMIN)) {
1749 res = ax25_ctl_ioctl(cmd, (void *)arg);
1752 case SIOCAX25GETINFO:
1753 case SIOCAX25GETINFOOLD: {
1754 ax25_cb *ax25 = ax25_sk(sk);
1755 struct ax25_info_struct ax25_info;
1757 ax25_info.t1 = ax25->t1 / HZ;
1758 ax25_info.t2 = ax25->t2 / HZ;
1759 ax25_info.t3 = ax25->t3 / HZ;
1760 ax25_info.idle = ax25->idle / (60 * HZ);
1761 ax25_info.n2 = ax25->n2;
1762 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1763 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1764 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1765 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1766 ax25_info.n2count = ax25->n2count;
1767 ax25_info.state = ax25->state;
1768 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1769 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
1770 ax25_info.vs = ax25->vs;
1771 ax25_info.vr = ax25->vr;
1772 ax25_info.va = ax25->va;
1773 ax25_info.vs_max = ax25->vs; /* reserved */
1774 ax25_info.paclen = ax25->paclen;
1775 ax25_info.window = ax25->window;
1777 /* old structure? */
1778 if (cmd == SIOCAX25GETINFOOLD) {
1779 static int warned = 0;
1781 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1786 if (copy_to_user((void *)arg, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1791 if (copy_to_user((void *)arg, &ax25_info, sizeof(struct ax25_info_struct))) {
1800 case SIOCAX25ADDFWD:
1801 case SIOCAX25DELFWD: {
1802 struct ax25_fwd_struct ax25_fwd;
1803 if (!capable(CAP_NET_ADMIN)) {
1807 if (copy_from_user(&ax25_fwd, (void *)arg, sizeof(ax25_fwd))) {
1811 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1817 case SIOCGIFDSTADDR:
1818 case SIOCSIFDSTADDR:
1819 case SIOCGIFBRDADDR:
1820 case SIOCSIFBRDADDR:
1821 case SIOCGIFNETMASK:
1822 case SIOCSIFNETMASK:
1829 res = dev_ioctl(cmd, (void __user *)arg);
1837 #ifdef CONFIG_PROC_FS
1839 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1841 struct ax25_cb *ax25;
1842 struct hlist_node *node;
1845 spin_lock_bh(&ax25_list_lock);
1846 ax25_for_each(ax25, node, &ax25_list) {
1854 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1858 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1859 struct ax25_cb, ax25_node);
1862 static void ax25_info_stop(struct seq_file *seq, void *v)
1864 spin_unlock_bh(&ax25_list_lock);
1867 static int ax25_info_show(struct seq_file *seq, void *v)
1875 * 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
1878 seq_printf(seq, "%8.8lx %s %s%s ",
1880 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1881 ax2asc(&ax25->source_addr),
1882 ax25->iamdigi? "*":"");
1883 seq_printf(seq, "%s", ax2asc(&ax25->dest_addr));
1885 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1886 seq_printf(seq, ",%s%s",
1887 ax2asc(&ax25->digipeat->calls[k]),
1888 ax25->digipeat->repeated[k]? "*":"");
1891 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1893 ax25->vs, ax25->vr, ax25->va,
1894 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1895 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1896 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1897 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1898 ax25->idle / (60 * HZ),
1899 ax25->n2count, ax25->n2,
1904 if (ax25->sk != NULL) {
1905 bh_lock_sock(ax25->sk);
1906 seq_printf(seq," %d %d %ld\n",
1907 atomic_read(&ax25->sk->sk_wmem_alloc),
1908 atomic_read(&ax25->sk->sk_rmem_alloc),
1909 ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L);
1910 bh_unlock_sock(ax25->sk);
1912 seq_puts(seq, " * * *\n");
1917 static struct seq_operations ax25_info_seqops = {
1918 .start = ax25_info_start,
1919 .next = ax25_info_next,
1920 .stop = ax25_info_stop,
1921 .show = ax25_info_show,
1924 static int ax25_info_open(struct inode *inode, struct file *file)
1926 return seq_open(file, &ax25_info_seqops);
1929 static struct file_operations ax25_info_fops = {
1930 .owner = THIS_MODULE,
1931 .open = ax25_info_open,
1933 .llseek = seq_lseek,
1934 .release = seq_release,
1939 static struct net_proto_family ax25_family_ops = {
1941 .create = ax25_create,
1942 .owner = THIS_MODULE,
1945 static struct proto_ops ax25_proto_ops = {
1947 .owner = THIS_MODULE,
1948 .release = ax25_release,
1950 .connect = ax25_connect,
1951 .socketpair = sock_no_socketpair,
1952 .accept = ax25_accept,
1953 .getname = ax25_getname,
1954 .poll = datagram_poll,
1955 .ioctl = ax25_ioctl,
1956 .listen = ax25_listen,
1957 .shutdown = ax25_shutdown,
1958 .setsockopt = ax25_setsockopt,
1959 .getsockopt = ax25_getsockopt,
1960 .sendmsg = ax25_sendmsg,
1961 .recvmsg = ax25_recvmsg,
1962 .mmap = sock_no_mmap,
1963 .sendpage = sock_no_sendpage,
1967 * Called by socket.c on kernel start up
1969 static struct packet_type ax25_packet_type = {
1970 .type = __constant_htons(ETH_P_AX25),
1971 .dev = NULL, /* All devices */
1972 .func = ax25_kiss_rcv,
1975 static struct notifier_block ax25_dev_notifier = {
1976 .notifier_call =ax25_device_event,
1979 EXPORT_SYMBOL(ax25_encapsulate);
1980 EXPORT_SYMBOL(ax25_rebuild_header);
1981 EXPORT_SYMBOL(ax25_findbyuid);
1982 EXPORT_SYMBOL(ax25_find_cb);
1983 EXPORT_SYMBOL(ax25_linkfail_register);
1984 EXPORT_SYMBOL(ax25_linkfail_release);
1985 EXPORT_SYMBOL(ax25_listen_register);
1986 EXPORT_SYMBOL(ax25_listen_release);
1987 EXPORT_SYMBOL(ax25_protocol_register);
1988 EXPORT_SYMBOL(ax25_protocol_release);
1989 EXPORT_SYMBOL(ax25_send_frame);
1990 EXPORT_SYMBOL(ax25_uid_policy);
1991 EXPORT_SYMBOL(ax25cmp);
1992 EXPORT_SYMBOL(ax2asc);
1993 EXPORT_SYMBOL(asc2ax);
1994 EXPORT_SYMBOL(null_ax25_address);
1995 EXPORT_SYMBOL(ax25_display_timer);
1997 static int __init ax25_init(void)
1999 sock_register(&ax25_family_ops);
2000 dev_add_pack(&ax25_packet_type);
2001 register_netdevice_notifier(&ax25_dev_notifier);
2002 ax25_register_sysctl();
2004 proc_net_fops_create("ax25_route", S_IRUGO, &ax25_route_fops);
2005 proc_net_fops_create("ax25", S_IRUGO, &ax25_info_fops);
2006 proc_net_fops_create("ax25_calls", S_IRUGO, &ax25_uid_fops);
2010 module_init(ax25_init);
2013 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2014 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2015 MODULE_LICENSE("GPL");
2016 MODULE_ALIAS_NETPROTO(PF_AX25);
2018 static void __exit ax25_exit(void)
2020 proc_net_remove("ax25_route");
2021 proc_net_remove("ax25");
2022 proc_net_remove("ax25_calls");
2027 ax25_unregister_sysctl();
2028 unregister_netdevice_notifier(&ax25_dev_notifier);
2030 dev_remove_pack(&ax25_packet_type);
2032 sock_unregister(PF_AX25);
2034 module_exit(ax25_exit);