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>
28 #include <linux/slab.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 <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/sysctl.h>
44 #include <linux/init.h>
45 #include <linux/spinlock.h>
46 #include <net/net_namespace.h>
47 #include <net/tcp_states.h>
53 HLIST_HEAD(ax25_list);
54 DEFINE_SPINLOCK(ax25_list_lock);
56 static const struct proto_ops ax25_proto_ops;
58 static void ax25_free_sock(struct sock *sk)
60 ax25_cb_put(sk_to_ax25(sk));
64 * Socket removal during an interrupt is now safe.
66 static void ax25_cb_del(ax25_cb *ax25)
68 if (!hlist_unhashed(&ax25->ax25_node)) {
69 spin_lock_bh(&ax25_list_lock);
70 hlist_del_init(&ax25->ax25_node);
71 spin_unlock_bh(&ax25_list_lock);
77 * Kill all bound sockets on a dropped device.
79 static void ax25_kill_by_device(struct net_device *dev)
84 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
87 spin_lock_bh(&ax25_list_lock);
89 ax25_for_each(s, &ax25_list) {
90 if (s->ax25_dev == ax25_dev) {
92 spin_unlock_bh(&ax25_list_lock);
93 ax25_disconnect(s, ENETUNREACH);
94 spin_lock_bh(&ax25_list_lock);
96 /* The entry could have been deleted from the
97 * list meanwhile and thus the next pointer is
98 * no longer valid. Play it safe and restart
99 * the scan. Forward progress is ensured
100 * because we set s->ax25_dev to NULL and we
101 * are never passed a NULL 'dev' argument.
106 spin_unlock_bh(&ax25_list_lock);
110 * Handle device status changes.
112 static int ax25_device_event(struct notifier_block *this, unsigned long event,
115 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
117 if (!net_eq(dev_net(dev), &init_net))
120 /* Reject non AX.25 devices */
121 if (dev->type != ARPHRD_AX25)
126 ax25_dev_device_up(dev);
129 ax25_kill_by_device(dev);
130 ax25_rt_device_down(dev);
131 ax25_dev_device_down(dev);
141 * Add a socket to the bound sockets list.
143 void ax25_cb_add(ax25_cb *ax25)
145 spin_lock_bh(&ax25_list_lock);
147 hlist_add_head(&ax25->ax25_node, &ax25_list);
148 spin_unlock_bh(&ax25_list_lock);
152 * Find a socket that wants to accept the SABM we have just
155 struct sock *ax25_find_listener(ax25_address *addr, int digi,
156 struct net_device *dev, int type)
160 spin_lock(&ax25_list_lock);
161 ax25_for_each(s, &ax25_list) {
162 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
164 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
165 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
166 /* If device is null we match any device */
167 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
169 spin_unlock(&ax25_list_lock);
174 spin_unlock(&ax25_list_lock);
180 * Find an AX.25 socket given both ends.
182 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
185 struct sock *sk = NULL;
188 spin_lock(&ax25_list_lock);
189 ax25_for_each(s, &ax25_list) {
190 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
191 !ax25cmp(&s->dest_addr, dest_addr) &&
192 s->sk->sk_type == type) {
199 spin_unlock(&ax25_list_lock);
205 * Find an AX.25 control block given both ends. It will only pick up
206 * floating AX.25 control blocks or non Raw socket bound control blocks.
208 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
209 ax25_digi *digi, struct net_device *dev)
213 spin_lock_bh(&ax25_list_lock);
214 ax25_for_each(s, &ax25_list) {
215 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
217 if (s->ax25_dev == NULL)
219 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
220 if (digi != NULL && digi->ndigi != 0) {
221 if (s->digipeat == NULL)
223 if (ax25digicmp(s->digipeat, digi) != 0)
226 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
230 spin_unlock_bh(&ax25_list_lock);
235 spin_unlock_bh(&ax25_list_lock);
240 EXPORT_SYMBOL(ax25_find_cb);
242 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
245 struct sk_buff *copy;
247 spin_lock(&ax25_list_lock);
248 ax25_for_each(s, &ax25_list) {
249 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
250 s->sk->sk_type == SOCK_RAW &&
251 s->sk->sk_protocol == proto &&
252 s->ax25_dev->dev == skb->dev &&
253 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
254 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
256 if (sock_queue_rcv_skb(s->sk, copy) != 0)
260 spin_unlock(&ax25_list_lock);
266 void ax25_destroy_socket(ax25_cb *);
269 * Handler for deferred kills.
271 static void ax25_destroy_timer(unsigned long data)
273 ax25_cb *ax25=(ax25_cb *)data;
280 ax25_destroy_socket(ax25);
286 * This is called from user mode and the timers. Thus it protects itself
287 * against interrupt users but doesn't worry about being called during
288 * work. Once it is removed from the queue no interrupt or bottom half
289 * will touch it and we are (fairly 8-) ) safe.
291 void ax25_destroy_socket(ax25_cb *ax25)
297 ax25_stop_heartbeat(ax25);
298 ax25_stop_t1timer(ax25);
299 ax25_stop_t2timer(ax25);
300 ax25_stop_t3timer(ax25);
301 ax25_stop_idletimer(ax25);
303 ax25_clear_queues(ax25); /* Flush the queues */
305 if (ax25->sk != NULL) {
306 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
307 if (skb->sk != ax25->sk) {
308 /* A pending connection */
309 ax25_cb *sax25 = sk_to_ax25(skb->sk);
311 /* Queue the unaccepted socket for death */
312 sock_orphan(skb->sk);
314 /* 9A4GL: hack to release unaccepted sockets */
315 skb->sk->sk_state = TCP_LISTEN;
317 ax25_start_heartbeat(sax25);
318 sax25->state = AX25_STATE_0;
323 skb_queue_purge(&ax25->sk->sk_write_queue);
326 if (ax25->sk != NULL) {
327 if (sk_has_allocations(ax25->sk)) {
328 /* Defer: outstanding buffers */
329 setup_timer(&ax25->dtimer, ax25_destroy_timer,
330 (unsigned long)ax25);
331 ax25->dtimer.expires = jiffies + 2 * HZ;
332 add_timer(&ax25->dtimer);
334 struct sock *sk=ax25->sk;
344 * dl1bke 960311: set parameters for existing AX.25 connections,
345 * includes a KILL command to abort any connection.
346 * VERY useful for debugging ;-)
348 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
350 struct ax25_ctl_struct ax25_ctl;
357 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
360 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
363 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
366 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
369 digi.ndigi = ax25_ctl.digi_count;
370 for (k = 0; k < digi.ndigi; k++)
371 digi.calls[k] = ax25_ctl.digi_addr[k];
373 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
376 switch (ax25_ctl.cmd) {
378 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
379 #ifdef CONFIG_AX25_DAMA_SLAVE
380 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
383 ax25_disconnect(ax25, ENETRESET);
387 if (ax25->modulus == AX25_MODULUS) {
388 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
391 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
394 ax25->window = ax25_ctl.arg;
398 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
400 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
401 ax25->t1 = ax25_ctl.arg * HZ;
405 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
407 ax25->t2 = ax25_ctl.arg * HZ;
411 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
414 ax25->n2 = ax25_ctl.arg;
418 if (ax25_ctl.arg > ULONG_MAX / HZ)
420 ax25->t3 = ax25_ctl.arg * HZ;
424 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
427 ax25->idle = ax25_ctl.arg * 60 * HZ;
431 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
433 ax25->paclen = ax25_ctl.arg;
449 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
451 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
452 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
453 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
454 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
455 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
456 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
457 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
458 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
460 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
461 ax25->modulus = AX25_EMODULUS;
462 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
464 ax25->modulus = AX25_MODULUS;
465 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
470 * Fill in a created AX.25 created control block with the default
471 * values for a particular device.
473 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
475 ax25->ax25_dev = ax25_dev;
477 if (ax25->ax25_dev != NULL) {
478 ax25_fillin_cb_from_dev(ax25, ax25_dev);
483 * No device, use kernel / AX.25 spec default values
485 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
486 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
487 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
488 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
489 ax25->n2 = AX25_DEF_N2;
490 ax25->paclen = AX25_DEF_PACLEN;
491 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
492 ax25->backoff = AX25_DEF_BACKOFF;
494 if (AX25_DEF_AXDEFMODE) {
495 ax25->modulus = AX25_EMODULUS;
496 ax25->window = AX25_DEF_EWINDOW;
498 ax25->modulus = AX25_MODULUS;
499 ax25->window = AX25_DEF_WINDOW;
504 * Create an empty AX.25 control block.
506 ax25_cb *ax25_create_cb(void)
510 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
513 atomic_set(&ax25->refcount, 1);
515 skb_queue_head_init(&ax25->write_queue);
516 skb_queue_head_init(&ax25->frag_queue);
517 skb_queue_head_init(&ax25->ack_queue);
518 skb_queue_head_init(&ax25->reseq_queue);
520 ax25_setup_timers(ax25);
522 ax25_fillin_cb(ax25, NULL);
524 ax25->state = AX25_STATE_0;
530 * Handling for system calls applied via the various interfaces to an
534 static int ax25_setsockopt(struct socket *sock, int level, int optname,
535 char __user *optval, unsigned int optlen)
537 struct sock *sk = sock->sk;
539 struct net_device *dev;
540 char devname[IFNAMSIZ];
544 if (level != SOL_AX25)
547 if (optlen < sizeof(unsigned int))
550 if (get_user(opt, (unsigned int __user *)optval))
554 ax25 = sk_to_ax25(sk);
558 if (ax25->modulus == AX25_MODULUS) {
559 if (opt < 1 || opt > 7) {
564 if (opt < 1 || opt > 63) {
573 if (opt < 1 || opt > ULONG_MAX / HZ) {
577 ax25->rtt = (opt * HZ) >> 1;
582 if (opt < 1 || opt > ULONG_MAX / HZ) {
590 if (opt < 1 || opt > 31) {
598 if (opt < 1 || opt > ULONG_MAX / HZ) {
606 if (opt > ULONG_MAX / (60 * HZ)) {
610 ax25->idle = opt * 60 * HZ;
622 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
626 ax25->pidincl = opt ? 1 : 0;
630 ax25->iamdigi = opt ? 1 : 0;
634 if (opt < 16 || opt > 65535) {
641 case SO_BINDTODEVICE:
642 if (optlen > IFNAMSIZ - 1)
643 optlen = IFNAMSIZ - 1;
645 memset(devname, 0, sizeof(devname));
647 if (copy_from_user(devname, optval, optlen)) {
652 if (sk->sk_type == SOCK_SEQPACKET &&
653 (sock->state != SS_UNCONNECTED ||
654 sk->sk_state == TCP_LISTEN)) {
655 res = -EADDRNOTAVAIL;
660 dev = __dev_get_by_name(&init_net, devname);
667 ax25->ax25_dev = ax25_dev_ax25dev(dev);
668 if (!ax25->ax25_dev) {
673 ax25_fillin_cb(ax25, ax25->ax25_dev);
685 static int ax25_getsockopt(struct socket *sock, int level, int optname,
686 char __user *optval, int __user *optlen)
688 struct sock *sk = sock->sk;
690 struct ax25_dev *ax25_dev;
691 char devname[IFNAMSIZ];
696 if (level != SOL_AX25)
699 if (get_user(maxlen, optlen))
705 valptr = (void *) &val;
706 length = min_t(unsigned int, maxlen, sizeof(int));
709 ax25 = sk_to_ax25(sk);
733 val = ax25->idle / (60 * HZ);
741 val = (ax25->modulus == AX25_EMODULUS);
756 case SO_BINDTODEVICE:
757 ax25_dev = ax25->ax25_dev;
759 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
760 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
761 length = strlen(devname) + 1;
767 valptr = (void *) devname;
776 if (put_user(length, optlen))
779 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
782 static int ax25_listen(struct socket *sock, int backlog)
784 struct sock *sk = sock->sk;
788 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
789 sk->sk_max_ack_backlog = backlog;
790 sk->sk_state = TCP_LISTEN;
802 * XXX: when creating ax25_sock we should update the .obj_size setting
805 static struct proto ax25_proto = {
807 .owner = THIS_MODULE,
808 .obj_size = sizeof(struct ax25_sock),
811 static int ax25_create(struct net *net, struct socket *sock, int protocol,
817 if (protocol < 0 || protocol > SK_PROTOCOL_MAX)
820 if (!net_eq(net, &init_net))
821 return -EAFNOSUPPORT;
823 switch (sock->type) {
825 if (protocol == 0 || protocol == PF_AX25)
826 protocol = AX25_P_TEXT;
832 case PF_AX25: /* For CLX */
833 protocol = AX25_P_TEXT;
846 return -ESOCKTNOSUPPORT;
847 #ifdef CONFIG_NETROM_MODULE
849 if (ax25_protocol_is_registered(AX25_P_NETROM))
850 return -ESOCKTNOSUPPORT;
853 #ifdef CONFIG_ROSE_MODULE
855 if (ax25_protocol_is_registered(AX25_P_ROSE))
856 return -ESOCKTNOSUPPORT;
864 if (!capable(CAP_NET_RAW))
868 return -ESOCKTNOSUPPORT;
871 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
875 ax25 = ax25_sk(sk)->cb = ax25_create_cb();
881 sock_init_data(sock, sk);
883 sk->sk_destruct = ax25_free_sock;
884 sock->ops = &ax25_proto_ops;
885 sk->sk_protocol = protocol;
892 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
895 ax25_cb *ax25, *oax25;
897 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
901 if ((ax25 = ax25_create_cb()) == NULL) {
906 switch (osk->sk_type) {
917 sock_init_data(NULL, sk);
919 sk->sk_type = osk->sk_type;
920 sk->sk_priority = osk->sk_priority;
921 sk->sk_protocol = osk->sk_protocol;
922 sk->sk_rcvbuf = osk->sk_rcvbuf;
923 sk->sk_sndbuf = osk->sk_sndbuf;
924 sk->sk_state = TCP_ESTABLISHED;
925 sock_copy_flags(sk, osk);
927 oax25 = sk_to_ax25(osk);
929 ax25->modulus = oax25->modulus;
930 ax25->backoff = oax25->backoff;
931 ax25->pidincl = oax25->pidincl;
932 ax25->iamdigi = oax25->iamdigi;
933 ax25->rtt = oax25->rtt;
934 ax25->t1 = oax25->t1;
935 ax25->t2 = oax25->t2;
936 ax25->t3 = oax25->t3;
937 ax25->n2 = oax25->n2;
938 ax25->idle = oax25->idle;
939 ax25->paclen = oax25->paclen;
940 ax25->window = oax25->window;
942 ax25->ax25_dev = ax25_dev;
943 ax25->source_addr = oax25->source_addr;
945 if (oax25->digipeat != NULL) {
946 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
948 if (ax25->digipeat == NULL) {
955 ax25_sk(sk)->cb = ax25;
956 sk->sk_destruct = ax25_free_sock;
962 static int ax25_release(struct socket *sock)
964 struct sock *sk = sock->sk;
973 ax25 = sk_to_ax25(sk);
975 if (sk->sk_type == SOCK_SEQPACKET) {
976 switch (ax25->state) {
979 ax25_disconnect(ax25, 0);
981 ax25_destroy_socket(ax25);
986 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
988 ax25_disconnect(ax25, 0);
990 if (!sock_flag(ax25->sk, SOCK_DESTROY))
991 ax25_destroy_socket(ax25);
996 ax25_clear_queues(ax25);
999 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1000 case AX25_PROTO_STD_SIMPLEX:
1001 case AX25_PROTO_STD_DUPLEX:
1002 ax25_send_control(ax25,
1006 ax25_stop_t2timer(ax25);
1007 ax25_stop_t3timer(ax25);
1008 ax25_stop_idletimer(ax25);
1010 #ifdef CONFIG_AX25_DAMA_SLAVE
1011 case AX25_PROTO_DAMA_SLAVE:
1012 ax25_stop_t3timer(ax25);
1013 ax25_stop_idletimer(ax25);
1017 ax25_calculate_t1(ax25);
1018 ax25_start_t1timer(ax25);
1019 ax25->state = AX25_STATE_2;
1020 sk->sk_state = TCP_CLOSE;
1021 sk->sk_shutdown |= SEND_SHUTDOWN;
1022 sk->sk_state_change(sk);
1023 sock_set_flag(sk, SOCK_DESTROY);
1030 sk->sk_state = TCP_CLOSE;
1031 sk->sk_shutdown |= SEND_SHUTDOWN;
1032 sk->sk_state_change(sk);
1033 ax25_destroy_socket(ax25);
1044 * We support a funny extension here so you can (as root) give any callsign
1045 * digipeated via a local address as source. This hack is obsolete now
1046 * that we've implemented support for SO_BINDTODEVICE. It is however small
1047 * and trivially backward compatible.
1049 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1051 struct sock *sk = sock->sk;
1052 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1053 ax25_dev *ax25_dev = NULL;
1054 ax25_uid_assoc *user;
1059 if (addr_len != sizeof(struct sockaddr_ax25) &&
1060 addr_len != sizeof(struct full_sockaddr_ax25))
1061 /* support for old structure may go away some time
1062 * ax25_bind(): uses old (6 digipeater) socket structure.
1064 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1065 (addr_len > sizeof(struct full_sockaddr_ax25)))
1068 if (addr->fsa_ax25.sax25_family != AF_AX25)
1071 user = ax25_findbyuid(current_euid());
1076 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1079 call = addr->fsa_ax25.sax25_call;
1084 ax25 = sk_to_ax25(sk);
1085 if (!sock_flag(sk, SOCK_ZAPPED)) {
1090 ax25->source_addr = call;
1093 * User already set interface with SO_BINDTODEVICE
1095 if (ax25->ax25_dev != NULL)
1098 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1099 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1100 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1101 err = -EADDRNOTAVAIL;
1105 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1106 err = -EADDRNOTAVAIL;
1111 if (ax25_dev != NULL)
1112 ax25_fillin_cb(ax25, ax25_dev);
1116 sock_reset_flag(sk, SOCK_ZAPPED);
1125 * FIXME: nonblock behaviour looks like it may have a bug.
1127 static int __must_check ax25_connect(struct socket *sock,
1128 struct sockaddr *uaddr, int addr_len, int flags)
1130 struct sock *sk = sock->sk;
1131 ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1132 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1133 ax25_digi *digi = NULL;
1134 int ct = 0, err = 0;
1137 * some sanity checks. code further down depends on this
1140 if (addr_len == sizeof(struct sockaddr_ax25))
1141 /* support for this will go away in early 2.5.x
1142 * ax25_connect(): uses obsolete socket structure
1145 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1146 /* support for old structure may go away some time
1147 * ax25_connect(): uses old (6 digipeater) socket structure.
1149 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1150 (addr_len > sizeof(struct full_sockaddr_ax25)))
1154 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1159 /* deal with restarts */
1160 if (sock->state == SS_CONNECTING) {
1161 switch (sk->sk_state) {
1162 case TCP_SYN_SENT: /* still trying */
1166 case TCP_ESTABLISHED: /* connection established */
1167 sock->state = SS_CONNECTED;
1170 case TCP_CLOSE: /* connection refused */
1171 sock->state = SS_UNCONNECTED;
1172 err = -ECONNREFUSED;
1177 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1178 err = -EISCONN; /* No reconnect on a seqpacket socket */
1182 sk->sk_state = TCP_CLOSE;
1183 sock->state = SS_UNCONNECTED;
1185 kfree(ax25->digipeat);
1186 ax25->digipeat = NULL;
1189 * Handle digi-peaters to be used.
1191 if (addr_len > sizeof(struct sockaddr_ax25) &&
1192 fsa->fsa_ax25.sax25_ndigis != 0) {
1193 /* Valid number of digipeaters ? */
1194 if (fsa->fsa_ax25.sax25_ndigis < 1 ||
1195 fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS ||
1196 addr_len < sizeof(struct sockaddr_ax25) +
1197 sizeof(ax25_address) * fsa->fsa_ax25.sax25_ndigis) {
1202 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1207 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1208 digi->lastrepeat = -1;
1210 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1211 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1212 AX25_HBIT) && ax25->iamdigi) {
1213 digi->repeated[ct] = 1;
1214 digi->lastrepeat = ct;
1216 digi->repeated[ct] = 0;
1218 digi->calls[ct] = fsa->fsa_digipeater[ct];
1224 * Must bind first - autobinding in this may or may not work. If
1225 * the socket is already bound, check to see if the device has
1226 * been filled in, error if it hasn't.
1228 if (sock_flag(sk, SOCK_ZAPPED)) {
1229 /* check if we can remove this feature. It is broken. */
1230 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1232 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1237 ax25_fillin_cb(ax25, ax25->ax25_dev);
1240 if (ax25->ax25_dev == NULL) {
1242 err = -EHOSTUNREACH;
1247 if (sk->sk_type == SOCK_SEQPACKET &&
1248 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1249 ax25->ax25_dev->dev))) {
1251 err = -EADDRINUSE; /* Already such a connection */
1256 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1257 ax25->digipeat = digi;
1259 /* First the easy one */
1260 if (sk->sk_type != SOCK_SEQPACKET) {
1261 sock->state = SS_CONNECTED;
1262 sk->sk_state = TCP_ESTABLISHED;
1266 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1267 sock->state = SS_CONNECTING;
1268 sk->sk_state = TCP_SYN_SENT;
1270 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1271 case AX25_PROTO_STD_SIMPLEX:
1272 case AX25_PROTO_STD_DUPLEX:
1273 ax25_std_establish_data_link(ax25);
1276 #ifdef CONFIG_AX25_DAMA_SLAVE
1277 case AX25_PROTO_DAMA_SLAVE:
1278 ax25->modulus = AX25_MODULUS;
1279 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1280 if (ax25->ax25_dev->dama.slave)
1281 ax25_ds_establish_data_link(ax25);
1283 ax25_std_establish_data_link(ax25);
1288 ax25->state = AX25_STATE_1;
1290 ax25_start_heartbeat(ax25);
1293 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1298 if (sk->sk_state == TCP_SYN_SENT) {
1302 prepare_to_wait(sk_sleep(sk), &wait,
1303 TASK_INTERRUPTIBLE);
1304 if (sk->sk_state != TCP_SYN_SENT)
1306 if (!signal_pending(current)) {
1315 finish_wait(sk_sleep(sk), &wait);
1321 if (sk->sk_state != TCP_ESTABLISHED) {
1322 /* Not in ABM, not in WAIT_UA -> failed */
1323 sock->state = SS_UNCONNECTED;
1324 err = sock_error(sk); /* Always set at this point */
1328 sock->state = SS_CONNECTED;
1337 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1339 struct sk_buff *skb;
1345 if (sock->state != SS_UNCONNECTED)
1348 if ((sk = sock->sk) == NULL)
1352 if (sk->sk_type != SOCK_SEQPACKET) {
1357 if (sk->sk_state != TCP_LISTEN) {
1363 * The read queue this time is holding sockets ready to use
1364 * hooked into the SABM we saved
1367 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1368 skb = skb_dequeue(&sk->sk_receive_queue);
1372 if (flags & O_NONBLOCK) {
1376 if (!signal_pending(current)) {
1385 finish_wait(sk_sleep(sk), &wait);
1391 sock_graft(newsk, newsock);
1393 /* Now attach up the new socket */
1395 sk->sk_ack_backlog--;
1396 newsock->state = SS_CONNECTED;
1404 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1405 int *uaddr_len, int peer)
1407 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1408 struct sock *sk = sock->sk;
1409 unsigned char ndigi, i;
1413 memset(fsa, 0, sizeof(*fsa));
1415 ax25 = sk_to_ax25(sk);
1418 if (sk->sk_state != TCP_ESTABLISHED) {
1423 fsa->fsa_ax25.sax25_family = AF_AX25;
1424 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1426 if (ax25->digipeat != NULL) {
1427 ndigi = ax25->digipeat->ndigi;
1428 fsa->fsa_ax25.sax25_ndigis = ndigi;
1429 for (i = 0; i < ndigi; i++)
1430 fsa->fsa_digipeater[i] =
1431 ax25->digipeat->calls[i];
1434 fsa->fsa_ax25.sax25_family = AF_AX25;
1435 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1436 fsa->fsa_ax25.sax25_ndigis = 1;
1437 if (ax25->ax25_dev != NULL) {
1438 memcpy(&fsa->fsa_digipeater[0],
1439 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1441 fsa->fsa_digipeater[0] = null_ax25_address;
1444 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1452 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1454 DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1455 struct sock *sk = sock->sk;
1456 struct sockaddr_ax25 sax;
1457 struct sk_buff *skb;
1458 ax25_digi dtmp, *dp;
1461 int lv, err, addr_len = msg->msg_namelen;
1463 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1467 ax25 = sk_to_ax25(sk);
1469 if (sock_flag(sk, SOCK_ZAPPED)) {
1470 err = -EADDRNOTAVAIL;
1474 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1475 send_sig(SIGPIPE, current, 0);
1480 if (ax25->ax25_dev == NULL) {
1485 if (len > ax25->ax25_dev->dev->mtu) {
1491 if (usax->sax25_family != AF_AX25) {
1496 if (addr_len == sizeof(struct sockaddr_ax25))
1497 /* ax25_sendmsg(): uses obsolete socket structure */
1499 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1500 /* support for old structure may go away some time
1501 * ax25_sendmsg(): uses old (6 digipeater)
1504 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1505 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1511 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1513 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1515 /* Valid number of digipeaters ? */
1516 if (usax->sax25_ndigis < 1 ||
1517 usax->sax25_ndigis > AX25_MAX_DIGIS ||
1518 addr_len < sizeof(struct sockaddr_ax25) +
1519 sizeof(ax25_address) * usax->sax25_ndigis) {
1524 dtmp.ndigi = usax->sax25_ndigis;
1526 while (ct < usax->sax25_ndigis) {
1527 dtmp.repeated[ct] = 0;
1528 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1532 dtmp.lastrepeat = 0;
1536 if (sk->sk_type == SOCK_SEQPACKET &&
1537 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1541 if (usax->sax25_ndigis == 0)
1547 * FIXME: 1003.1g - if the socket is like this because
1548 * it has become closed (not started closed) and is VC
1549 * we ought to SIGPIPE, EPIPE
1551 if (sk->sk_state != TCP_ESTABLISHED) {
1555 sax.sax25_family = AF_AX25;
1556 sax.sax25_call = ax25->dest_addr;
1557 dp = ax25->digipeat;
1560 /* Build a packet */
1561 /* Assume the worst case */
1562 size = len + ax25->ax25_dev->dev->hard_header_len;
1564 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1568 skb_reserve(skb, size - len);
1570 /* User data follows immediately after the AX.25 data */
1571 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1577 skb_reset_network_header(skb);
1579 /* Add the PID if one is not supplied by the user in the skb */
1581 *skb_push(skb, 1) = sk->sk_protocol;
1583 if (sk->sk_type == SOCK_SEQPACKET) {
1584 /* Connected mode sockets go via the LAPB machine */
1585 if (sk->sk_state != TCP_ESTABLISHED) {
1591 /* Shove it onto the queue and kick */
1592 ax25_output(ax25, ax25->paclen, skb);
1598 skb_push(skb, 1 + ax25_addr_size(dp));
1600 /* Building AX.25 Header */
1602 /* Build an AX.25 header */
1603 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1604 dp, AX25_COMMAND, AX25_MODULUS);
1606 skb_set_transport_header(skb, lv);
1608 *skb_transport_header(skb) = AX25_UI;
1610 /* Datagram frames go straight out of the door as UI */
1611 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1621 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1624 struct sock *sk = sock->sk;
1625 struct sk_buff *skb;
1631 * This works for seqpacket too. The receiver has ordered the
1632 * queue for us! We do one quick check first though
1634 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1639 /* Now we can treat all alike */
1640 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1641 flags & MSG_DONTWAIT, &err);
1645 if (!sk_to_ax25(sk)->pidincl)
1646 skb_pull(skb, 1); /* Remove PID */
1648 skb_reset_transport_header(skb);
1651 if (copied > size) {
1653 msg->msg_flags |= MSG_TRUNC;
1656 skb_copy_datagram_msg(skb, 0, msg, copied);
1658 if (msg->msg_name) {
1661 const unsigned char *mac = skb_mac_header(skb);
1662 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1664 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1665 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1667 sax->sax25_family = AF_AX25;
1668 /* We set this correctly, even though we may not let the
1669 application know the digi calls further down (because it
1670 did NOT ask to know them). This could get political... **/
1671 sax->sax25_ndigis = digi.ndigi;
1672 sax->sax25_call = src;
1674 if (sax->sax25_ndigis != 0) {
1676 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1678 for (ct = 0; ct < digi.ndigi; ct++)
1679 fsa->fsa_digipeater[ct] = digi.calls[ct];
1681 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1684 skb_free_datagram(sk, skb);
1693 static int ax25_shutdown(struct socket *sk, int how)
1695 /* FIXME - generate DM and RNR states */
1699 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1701 struct sock *sk = sock->sk;
1702 void __user *argp = (void __user *)arg;
1710 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1713 res = put_user(amount, (int __user *)argp);
1718 struct sk_buff *skb;
1720 /* These two are safe on a single CPU system as only user tasks fiddle here */
1721 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1723 res = put_user(amount, (int __user *) argp);
1728 res = sock_get_timestamp(sk, argp);
1732 res = sock_get_timestampns(sk, argp);
1735 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1736 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1737 case SIOCAX25GETUID: {
1738 struct sockaddr_ax25 sax25;
1739 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1743 res = ax25_uid_ioctl(cmd, &sax25);
1747 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1749 if (!capable(CAP_NET_ADMIN)) {
1753 if (get_user(amount, (long __user *)argp)) {
1757 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1761 ax25_uid_policy = amount;
1769 if (!capable(CAP_NET_ADMIN)) {
1773 res = ax25_rt_ioctl(cmd, argp);
1776 case SIOCAX25CTLCON:
1777 if (!capable(CAP_NET_ADMIN)) {
1781 res = ax25_ctl_ioctl(cmd, argp);
1784 case SIOCAX25GETINFO:
1785 case SIOCAX25GETINFOOLD: {
1786 ax25_cb *ax25 = sk_to_ax25(sk);
1787 struct ax25_info_struct ax25_info;
1789 ax25_info.t1 = ax25->t1 / HZ;
1790 ax25_info.t2 = ax25->t2 / HZ;
1791 ax25_info.t3 = ax25->t3 / HZ;
1792 ax25_info.idle = ax25->idle / (60 * HZ);
1793 ax25_info.n2 = ax25->n2;
1794 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1795 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1796 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1797 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1798 ax25_info.n2count = ax25->n2count;
1799 ax25_info.state = ax25->state;
1800 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1801 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1802 ax25_info.vs = ax25->vs;
1803 ax25_info.vr = ax25->vr;
1804 ax25_info.va = ax25->va;
1805 ax25_info.vs_max = ax25->vs; /* reserved */
1806 ax25_info.paclen = ax25->paclen;
1807 ax25_info.window = ax25->window;
1809 /* old structure? */
1810 if (cmd == SIOCAX25GETINFOOLD) {
1811 static int warned = 0;
1813 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1818 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1823 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1832 case SIOCAX25ADDFWD:
1833 case SIOCAX25DELFWD: {
1834 struct ax25_fwd_struct ax25_fwd;
1835 if (!capable(CAP_NET_ADMIN)) {
1839 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1843 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1849 case SIOCGIFDSTADDR:
1850 case SIOCSIFDSTADDR:
1851 case SIOCGIFBRDADDR:
1852 case SIOCSIFBRDADDR:
1853 case SIOCGIFNETMASK:
1854 case SIOCSIFNETMASK:
1869 #ifdef CONFIG_PROC_FS
1871 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1872 __acquires(ax25_list_lock)
1874 spin_lock_bh(&ax25_list_lock);
1875 return seq_hlist_start(&ax25_list, *pos);
1878 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1880 return seq_hlist_next(v, &ax25_list, pos);
1883 static void ax25_info_stop(struct seq_file *seq, void *v)
1884 __releases(ax25_list_lock)
1886 spin_unlock_bh(&ax25_list_lock);
1889 static int ax25_info_show(struct seq_file *seq, void *v)
1891 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1898 * 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
1901 seq_printf(seq, "%8.8lx %s %s%s ",
1903 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1904 ax2asc(buf, &ax25->source_addr),
1905 ax25->iamdigi? "*":"");
1906 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1908 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1909 seq_printf(seq, ",%s%s",
1910 ax2asc(buf, &ax25->digipeat->calls[k]),
1911 ax25->digipeat->repeated[k]? "*":"");
1914 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1916 ax25->vs, ax25->vr, ax25->va,
1917 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1918 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1919 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1920 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1921 ax25->idle / (60 * HZ),
1922 ax25->n2count, ax25->n2,
1927 if (ax25->sk != NULL) {
1928 seq_printf(seq, " %d %d %lu\n",
1929 sk_wmem_alloc_get(ax25->sk),
1930 sk_rmem_alloc_get(ax25->sk),
1931 sock_i_ino(ax25->sk));
1933 seq_puts(seq, " * * *\n");
1938 static const struct seq_operations ax25_info_seqops = {
1939 .start = ax25_info_start,
1940 .next = ax25_info_next,
1941 .stop = ax25_info_stop,
1942 .show = ax25_info_show,
1945 static int ax25_info_open(struct inode *inode, struct file *file)
1947 return seq_open(file, &ax25_info_seqops);
1950 static const struct file_operations ax25_info_fops = {
1951 .owner = THIS_MODULE,
1952 .open = ax25_info_open,
1954 .llseek = seq_lseek,
1955 .release = seq_release,
1960 static const struct net_proto_family ax25_family_ops = {
1962 .create = ax25_create,
1963 .owner = THIS_MODULE,
1966 static const struct proto_ops ax25_proto_ops = {
1968 .owner = THIS_MODULE,
1969 .release = ax25_release,
1971 .connect = ax25_connect,
1972 .socketpair = sock_no_socketpair,
1973 .accept = ax25_accept,
1974 .getname = ax25_getname,
1975 .poll = datagram_poll,
1976 .ioctl = ax25_ioctl,
1977 .listen = ax25_listen,
1978 .shutdown = ax25_shutdown,
1979 .setsockopt = ax25_setsockopt,
1980 .getsockopt = ax25_getsockopt,
1981 .sendmsg = ax25_sendmsg,
1982 .recvmsg = ax25_recvmsg,
1983 .mmap = sock_no_mmap,
1984 .sendpage = sock_no_sendpage,
1988 * Called by socket.c on kernel start up
1990 static struct packet_type ax25_packet_type __read_mostly = {
1991 .type = cpu_to_be16(ETH_P_AX25),
1992 .func = ax25_kiss_rcv,
1995 static struct notifier_block ax25_dev_notifier = {
1996 .notifier_call = ax25_device_event,
1999 static int __init ax25_init(void)
2001 int rc = proto_register(&ax25_proto, 0);
2006 sock_register(&ax25_family_ops);
2007 dev_add_pack(&ax25_packet_type);
2008 register_netdevice_notifier(&ax25_dev_notifier);
2010 proc_create("ax25_route", S_IRUGO, init_net.proc_net,
2012 proc_create("ax25", S_IRUGO, init_net.proc_net, &ax25_info_fops);
2013 proc_create("ax25_calls", S_IRUGO, init_net.proc_net, &ax25_uid_fops);
2017 module_init(ax25_init);
2020 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2021 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2022 MODULE_LICENSE("GPL");
2023 MODULE_ALIAS_NETPROTO(PF_AX25);
2025 static void __exit ax25_exit(void)
2027 remove_proc_entry("ax25_route", init_net.proc_net);
2028 remove_proc_entry("ax25", init_net.proc_net);
2029 remove_proc_entry("ax25_calls", init_net.proc_net);
2031 unregister_netdevice_notifier(&ax25_dev_notifier);
2033 dev_remove_pack(&ax25_packet_type);
2035 sock_unregister(PF_AX25);
2036 proto_unregister(&ax25_proto);
2042 module_exit(ax25_exit);