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 DEFINE_SPINLOCK(ax25_list_lock);
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 __user *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 static 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) {
1184 ax25_fillin_cb(ax25, ax25->ax25_dev);
1187 if (ax25->ax25_dev == NULL) {
1189 err = -EHOSTUNREACH;
1194 if (sk->sk_type == SOCK_SEQPACKET &&
1195 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1196 ax25->ax25_dev->dev))) {
1198 err = -EADDRINUSE; /* Already such a connection */
1203 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1204 ax25->digipeat = digi;
1206 /* First the easy one */
1207 if (sk->sk_type != SOCK_SEQPACKET) {
1208 sock->state = SS_CONNECTED;
1209 sk->sk_state = TCP_ESTABLISHED;
1213 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1214 sock->state = SS_CONNECTING;
1215 sk->sk_state = TCP_SYN_SENT;
1217 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1218 case AX25_PROTO_STD_SIMPLEX:
1219 case AX25_PROTO_STD_DUPLEX:
1220 ax25_std_establish_data_link(ax25);
1223 #ifdef CONFIG_AX25_DAMA_SLAVE
1224 case AX25_PROTO_DAMA_SLAVE:
1225 ax25->modulus = AX25_MODULUS;
1226 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1227 if (ax25->ax25_dev->dama.slave)
1228 ax25_ds_establish_data_link(ax25);
1230 ax25_std_establish_data_link(ax25);
1235 ax25->state = AX25_STATE_1;
1237 ax25_start_heartbeat(ax25);
1240 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1245 if (sk->sk_state == TCP_SYN_SENT) {
1246 struct task_struct *tsk = current;
1247 DECLARE_WAITQUEUE(wait, tsk);
1249 add_wait_queue(sk->sk_sleep, &wait);
1251 if (sk->sk_state != TCP_SYN_SENT)
1253 set_current_state(TASK_INTERRUPTIBLE);
1255 if (!signal_pending(tsk)) {
1260 current->state = TASK_RUNNING;
1261 remove_wait_queue(sk->sk_sleep, &wait);
1262 return -ERESTARTSYS;
1264 current->state = TASK_RUNNING;
1265 remove_wait_queue(sk->sk_sleep, &wait);
1268 if (sk->sk_state != TCP_ESTABLISHED) {
1269 /* Not in ABM, not in WAIT_UA -> failed */
1270 sock->state = SS_UNCONNECTED;
1271 err = sock_error(sk); /* Always set at this point */
1275 sock->state = SS_CONNECTED;
1285 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1287 struct task_struct *tsk = current;
1288 DECLARE_WAITQUEUE(wait, tsk);
1289 struct sk_buff *skb;
1294 if (sock->state != SS_UNCONNECTED)
1297 if ((sk = sock->sk) == NULL)
1301 if (sk->sk_type != SOCK_SEQPACKET) {
1306 if (sk->sk_state != TCP_LISTEN) {
1312 * The read queue this time is holding sockets ready to use
1313 * hooked into the SABM we saved
1315 add_wait_queue(sk->sk_sleep, &wait);
1317 skb = skb_dequeue(&sk->sk_receive_queue);
1322 current->state = TASK_INTERRUPTIBLE;
1323 if (flags & O_NONBLOCK) {
1324 current->state = TASK_RUNNING;
1325 remove_wait_queue(sk->sk_sleep, &wait);
1326 return -EWOULDBLOCK;
1328 if (!signal_pending(tsk)) {
1333 current->state = TASK_RUNNING;
1334 remove_wait_queue(sk->sk_sleep, &wait);
1335 return -ERESTARTSYS;
1337 current->state = TASK_RUNNING;
1338 remove_wait_queue(sk->sk_sleep, &wait);
1341 newsk->sk_socket = newsock;
1342 newsk->sk_sleep = &newsock->wait;
1344 /* Now attach up the new socket */
1346 sk->sk_ack_backlog--;
1347 newsock->sk = newsk;
1348 newsock->state = SS_CONNECTED;
1356 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1357 int *uaddr_len, int peer)
1359 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1360 struct sock *sk = sock->sk;
1361 unsigned char ndigi, i;
1369 if (sk->sk_state != TCP_ESTABLISHED) {
1374 fsa->fsa_ax25.sax25_family = AF_AX25;
1375 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1376 fsa->fsa_ax25.sax25_ndigis = 0;
1378 if (ax25->digipeat != NULL) {
1379 ndigi = ax25->digipeat->ndigi;
1380 fsa->fsa_ax25.sax25_ndigis = ndigi;
1381 for (i = 0; i < ndigi; i++)
1382 fsa->fsa_digipeater[i] =
1383 ax25->digipeat->calls[i];
1386 fsa->fsa_ax25.sax25_family = AF_AX25;
1387 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1388 fsa->fsa_ax25.sax25_ndigis = 1;
1389 if (ax25->ax25_dev != NULL) {
1390 memcpy(&fsa->fsa_digipeater[0],
1391 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1393 fsa->fsa_digipeater[0] = null_ax25_address;
1396 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1404 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1405 struct msghdr *msg, size_t len)
1407 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1408 struct sock *sk = sock->sk;
1409 struct sockaddr_ax25 sax;
1410 struct sk_buff *skb;
1411 ax25_digi dtmp, *dp;
1412 unsigned char *asmptr;
1415 int lv, err, addr_len = msg->msg_namelen;
1417 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
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;
1672 void __user *argp = (void __user *)arg;
1679 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1682 res = put_user(amount, (int __user *)argp);
1687 struct sk_buff *skb;
1689 /* These two are safe on a single CPU system as only user tasks fiddle here */
1690 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1692 res = put_user(amount, (int __user *)argp);
1698 res = sock_get_timestamp(sk, argp);
1704 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1705 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1706 case SIOCAX25GETUID: {
1707 struct sockaddr_ax25 sax25;
1708 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1712 res = ax25_uid_ioctl(cmd, &sax25);
1716 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1718 if (!capable(CAP_NET_ADMIN)) {
1722 if (get_user(amount, (long __user *)argp)) {
1726 if (amount > AX25_NOUID_BLOCK) {
1730 ax25_uid_policy = amount;
1738 if (!capable(CAP_NET_ADMIN)) {
1742 res = ax25_rt_ioctl(cmd, argp);
1745 case SIOCAX25CTLCON:
1746 if (!capable(CAP_NET_ADMIN)) {
1750 res = ax25_ctl_ioctl(cmd, argp);
1753 case SIOCAX25GETINFO:
1754 case SIOCAX25GETINFOOLD: {
1755 ax25_cb *ax25 = ax25_sk(sk);
1756 struct ax25_info_struct ax25_info;
1758 ax25_info.t1 = ax25->t1 / HZ;
1759 ax25_info.t2 = ax25->t2 / HZ;
1760 ax25_info.t3 = ax25->t3 / HZ;
1761 ax25_info.idle = ax25->idle / (60 * HZ);
1762 ax25_info.n2 = ax25->n2;
1763 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1764 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1765 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1766 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1767 ax25_info.n2count = ax25->n2count;
1768 ax25_info.state = ax25->state;
1769 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1770 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
1771 ax25_info.vs = ax25->vs;
1772 ax25_info.vr = ax25->vr;
1773 ax25_info.va = ax25->va;
1774 ax25_info.vs_max = ax25->vs; /* reserved */
1775 ax25_info.paclen = ax25->paclen;
1776 ax25_info.window = ax25->window;
1778 /* old structure? */
1779 if (cmd == SIOCAX25GETINFOOLD) {
1780 static int warned = 0;
1782 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1787 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1792 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1801 case SIOCAX25ADDFWD:
1802 case SIOCAX25DELFWD: {
1803 struct ax25_fwd_struct ax25_fwd;
1804 if (!capable(CAP_NET_ADMIN)) {
1808 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1812 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1818 case SIOCGIFDSTADDR:
1819 case SIOCSIFDSTADDR:
1820 case SIOCGIFBRDADDR:
1821 case SIOCSIFBRDADDR:
1822 case SIOCGIFNETMASK:
1823 case SIOCSIFNETMASK:
1830 res = dev_ioctl(cmd, argp);
1838 #ifdef CONFIG_PROC_FS
1840 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1842 struct ax25_cb *ax25;
1843 struct hlist_node *node;
1846 spin_lock_bh(&ax25_list_lock);
1847 ax25_for_each(ax25, node, &ax25_list) {
1855 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1859 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1860 struct ax25_cb, ax25_node);
1863 static void ax25_info_stop(struct seq_file *seq, void *v)
1865 spin_unlock_bh(&ax25_list_lock);
1868 static int ax25_info_show(struct seq_file *seq, void *v)
1876 * 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
1879 seq_printf(seq, "%8.8lx %s %s%s ",
1881 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1882 ax2asc(&ax25->source_addr),
1883 ax25->iamdigi? "*":"");
1884 seq_printf(seq, "%s", ax2asc(&ax25->dest_addr));
1886 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1887 seq_printf(seq, ",%s%s",
1888 ax2asc(&ax25->digipeat->calls[k]),
1889 ax25->digipeat->repeated[k]? "*":"");
1892 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1894 ax25->vs, ax25->vr, ax25->va,
1895 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1896 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1897 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1898 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1899 ax25->idle / (60 * HZ),
1900 ax25->n2count, ax25->n2,
1905 if (ax25->sk != NULL) {
1906 bh_lock_sock(ax25->sk);
1907 seq_printf(seq," %d %d %ld\n",
1908 atomic_read(&ax25->sk->sk_wmem_alloc),
1909 atomic_read(&ax25->sk->sk_rmem_alloc),
1910 ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L);
1911 bh_unlock_sock(ax25->sk);
1913 seq_puts(seq, " * * *\n");
1918 static struct seq_operations ax25_info_seqops = {
1919 .start = ax25_info_start,
1920 .next = ax25_info_next,
1921 .stop = ax25_info_stop,
1922 .show = ax25_info_show,
1925 static int ax25_info_open(struct inode *inode, struct file *file)
1927 return seq_open(file, &ax25_info_seqops);
1930 static struct file_operations ax25_info_fops = {
1931 .owner = THIS_MODULE,
1932 .open = ax25_info_open,
1934 .llseek = seq_lseek,
1935 .release = seq_release,
1940 static struct net_proto_family ax25_family_ops = {
1942 .create = ax25_create,
1943 .owner = THIS_MODULE,
1946 static struct proto_ops ax25_proto_ops = {
1948 .owner = THIS_MODULE,
1949 .release = ax25_release,
1951 .connect = ax25_connect,
1952 .socketpair = sock_no_socketpair,
1953 .accept = ax25_accept,
1954 .getname = ax25_getname,
1955 .poll = datagram_poll,
1956 .ioctl = ax25_ioctl,
1957 .listen = ax25_listen,
1958 .shutdown = ax25_shutdown,
1959 .setsockopt = ax25_setsockopt,
1960 .getsockopt = ax25_getsockopt,
1961 .sendmsg = ax25_sendmsg,
1962 .recvmsg = ax25_recvmsg,
1963 .mmap = sock_no_mmap,
1964 .sendpage = sock_no_sendpage,
1968 * Called by socket.c on kernel start up
1970 static struct packet_type ax25_packet_type = {
1971 .type = __constant_htons(ETH_P_AX25),
1972 .dev = NULL, /* All devices */
1973 .func = ax25_kiss_rcv,
1976 static struct notifier_block ax25_dev_notifier = {
1977 .notifier_call =ax25_device_event,
1980 EXPORT_SYMBOL(ax25_encapsulate);
1981 EXPORT_SYMBOL(ax25_rebuild_header);
1982 EXPORT_SYMBOL(ax25_findbyuid);
1983 EXPORT_SYMBOL(ax25_find_cb);
1984 EXPORT_SYMBOL(ax25_linkfail_register);
1985 EXPORT_SYMBOL(ax25_linkfail_release);
1986 EXPORT_SYMBOL(ax25_listen_register);
1987 EXPORT_SYMBOL(ax25_listen_release);
1988 EXPORT_SYMBOL(ax25_protocol_register);
1989 EXPORT_SYMBOL(ax25_protocol_release);
1990 EXPORT_SYMBOL(ax25_send_frame);
1991 EXPORT_SYMBOL(ax25_uid_policy);
1992 EXPORT_SYMBOL(ax25cmp);
1993 EXPORT_SYMBOL(ax2asc);
1994 EXPORT_SYMBOL(asc2ax);
1995 EXPORT_SYMBOL(null_ax25_address);
1996 EXPORT_SYMBOL(ax25_display_timer);
1998 static int __init ax25_init(void)
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("ax25_route", S_IRUGO, &ax25_route_fops);
2006 proc_net_fops_create("ax25", S_IRUGO, &ax25_info_fops);
2007 proc_net_fops_create("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("ax25_route");
2022 proc_net_remove("ax25");
2023 proc_net_remove("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);
2035 module_exit(ax25_exit);