1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
5 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
6 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
7 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
8 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
9 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
10 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
11 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
13 #include <linux/capability.h>
14 #include <linux/module.h>
15 #include <linux/errno.h>
16 #include <linux/types.h>
17 #include <linux/socket.h>
19 #include <linux/kernel.h>
20 #include <linux/sched/signal.h>
21 #include <linux/timer.h>
22 #include <linux/string.h>
23 #include <linux/sockios.h>
24 #include <linux/net.h>
25 #include <linux/slab.h>
27 #include <linux/inet.h>
28 #include <linux/netdevice.h>
29 #include <linux/if_arp.h>
30 #include <linux/skbuff.h>
32 #include <linux/uaccess.h>
33 #include <linux/fcntl.h>
34 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
36 #include <linux/interrupt.h>
37 #include <linux/notifier.h>
38 #include <linux/proc_fs.h>
39 #include <linux/stat.h>
40 #include <linux/sysctl.h>
41 #include <linux/init.h>
42 #include <linux/spinlock.h>
43 #include <net/net_namespace.h>
44 #include <net/tcp_states.h>
50 HLIST_HEAD(ax25_list);
51 DEFINE_SPINLOCK(ax25_list_lock);
53 static const struct proto_ops ax25_proto_ops;
55 static void ax25_free_sock(struct sock *sk)
57 ax25_cb_put(sk_to_ax25(sk));
61 * Socket removal during an interrupt is now safe.
63 static void ax25_cb_del(ax25_cb *ax25)
65 if (!hlist_unhashed(&ax25->ax25_node)) {
66 spin_lock_bh(&ax25_list_lock);
67 hlist_del_init(&ax25->ax25_node);
68 spin_unlock_bh(&ax25_list_lock);
74 * Kill all bound sockets on a dropped device.
76 static void ax25_kill_by_device(struct net_device *dev)
82 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
85 spin_lock_bh(&ax25_list_lock);
87 ax25_for_each(s, &ax25_list) {
88 if (s->ax25_dev == ax25_dev) {
91 spin_unlock_bh(&ax25_list_lock);
92 ax25_disconnect(s, ENETUNREACH);
94 spin_lock_bh(&ax25_list_lock);
98 spin_unlock_bh(&ax25_list_lock);
100 ax25_disconnect(s, ENETUNREACH);
103 dev_put(ax25_dev->dev);
104 ax25_dev_put(ax25_dev);
107 spin_lock_bh(&ax25_list_lock);
109 /* The entry could have been deleted from the
110 * list meanwhile and thus the next pointer is
111 * no longer valid. Play it safe and restart
112 * the scan. Forward progress is ensured
113 * because we set s->ax25_dev to NULL and we
114 * are never passed a NULL 'dev' argument.
119 spin_unlock_bh(&ax25_list_lock);
123 * Handle device status changes.
125 static int ax25_device_event(struct notifier_block *this, unsigned long event,
128 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
130 if (!net_eq(dev_net(dev), &init_net))
133 /* Reject non AX.25 devices */
134 if (dev->type != ARPHRD_AX25)
139 ax25_dev_device_up(dev);
142 ax25_kill_by_device(dev);
143 ax25_rt_device_down(dev);
144 ax25_dev_device_down(dev);
154 * Add a socket to the bound sockets list.
156 void ax25_cb_add(ax25_cb *ax25)
158 spin_lock_bh(&ax25_list_lock);
160 hlist_add_head(&ax25->ax25_node, &ax25_list);
161 spin_unlock_bh(&ax25_list_lock);
165 * Find a socket that wants to accept the SABM we have just
168 struct sock *ax25_find_listener(ax25_address *addr, int digi,
169 struct net_device *dev, int type)
173 spin_lock(&ax25_list_lock);
174 ax25_for_each(s, &ax25_list) {
175 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
177 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
178 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
179 /* If device is null we match any device */
180 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
182 spin_unlock(&ax25_list_lock);
187 spin_unlock(&ax25_list_lock);
193 * Find an AX.25 socket given both ends.
195 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
198 struct sock *sk = NULL;
201 spin_lock(&ax25_list_lock);
202 ax25_for_each(s, &ax25_list) {
203 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
204 !ax25cmp(&s->dest_addr, dest_addr) &&
205 s->sk->sk_type == type) {
212 spin_unlock(&ax25_list_lock);
218 * Find an AX.25 control block given both ends. It will only pick up
219 * floating AX.25 control blocks or non Raw socket bound control blocks.
221 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
222 ax25_digi *digi, struct net_device *dev)
226 spin_lock_bh(&ax25_list_lock);
227 ax25_for_each(s, &ax25_list) {
228 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
230 if (s->ax25_dev == NULL)
232 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
233 if (digi != NULL && digi->ndigi != 0) {
234 if (s->digipeat == NULL)
236 if (ax25digicmp(s->digipeat, digi) != 0)
239 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
243 spin_unlock_bh(&ax25_list_lock);
248 spin_unlock_bh(&ax25_list_lock);
253 EXPORT_SYMBOL(ax25_find_cb);
255 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
258 struct sk_buff *copy;
260 spin_lock(&ax25_list_lock);
261 ax25_for_each(s, &ax25_list) {
262 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
263 s->sk->sk_type == SOCK_RAW &&
264 s->sk->sk_protocol == proto &&
265 s->ax25_dev->dev == skb->dev &&
266 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
267 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
269 if (sock_queue_rcv_skb(s->sk, copy) != 0)
273 spin_unlock(&ax25_list_lock);
279 void ax25_destroy_socket(ax25_cb *);
282 * Handler for deferred kills.
284 static void ax25_destroy_timer(struct timer_list *t)
286 ax25_cb *ax25 = from_timer(ax25, t, dtimer);
293 ax25_destroy_socket(ax25);
299 * This is called from user mode and the timers. Thus it protects itself
300 * against interrupt users but doesn't worry about being called during
301 * work. Once it is removed from the queue no interrupt or bottom half
302 * will touch it and we are (fairly 8-) ) safe.
304 void ax25_destroy_socket(ax25_cb *ax25)
310 ax25_stop_heartbeat(ax25);
311 ax25_stop_t1timer(ax25);
312 ax25_stop_t2timer(ax25);
313 ax25_stop_t3timer(ax25);
314 ax25_stop_idletimer(ax25);
316 ax25_clear_queues(ax25); /* Flush the queues */
318 if (ax25->sk != NULL) {
319 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
320 if (skb->sk != ax25->sk) {
321 /* A pending connection */
322 ax25_cb *sax25 = sk_to_ax25(skb->sk);
324 /* Queue the unaccepted socket for death */
325 sock_orphan(skb->sk);
327 /* 9A4GL: hack to release unaccepted sockets */
328 skb->sk->sk_state = TCP_LISTEN;
330 ax25_start_heartbeat(sax25);
331 sax25->state = AX25_STATE_0;
336 skb_queue_purge(&ax25->sk->sk_write_queue);
339 if (ax25->sk != NULL) {
340 if (sk_has_allocations(ax25->sk)) {
341 /* Defer: outstanding buffers */
342 timer_setup(&ax25->dtimer, ax25_destroy_timer, 0);
343 ax25->dtimer.expires = jiffies + 2 * HZ;
344 add_timer(&ax25->dtimer);
346 struct sock *sk=ax25->sk;
356 * dl1bke 960311: set parameters for existing AX.25 connections,
357 * includes a KILL command to abort any connection.
358 * VERY useful for debugging ;-)
360 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
362 struct ax25_ctl_struct ax25_ctl;
369 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
372 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
375 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
378 ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr);
382 digi.ndigi = ax25_ctl.digi_count;
383 for (k = 0; k < digi.ndigi; k++)
384 digi.calls[k] = ax25_ctl.digi_addr[k];
386 ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev);
388 ax25_dev_put(ax25_dev);
392 switch (ax25_ctl.cmd) {
394 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
395 #ifdef CONFIG_AX25_DAMA_SLAVE
396 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
399 ax25_disconnect(ax25, ENETRESET);
403 if (ax25->modulus == AX25_MODULUS) {
404 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
407 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
410 ax25->window = ax25_ctl.arg;
414 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
416 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
417 ax25->t1 = ax25_ctl.arg * HZ;
421 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
423 ax25->t2 = ax25_ctl.arg * HZ;
427 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
430 ax25->n2 = ax25_ctl.arg;
434 if (ax25_ctl.arg > ULONG_MAX / HZ)
436 ax25->t3 = ax25_ctl.arg * HZ;
440 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
443 ax25->idle = ax25_ctl.arg * 60 * HZ;
447 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
449 ax25->paclen = ax25_ctl.arg;
457 ax25_dev_put(ax25_dev);
466 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
468 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
469 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
470 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
471 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
472 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
473 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
474 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
475 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
477 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
478 ax25->modulus = AX25_EMODULUS;
479 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
481 ax25->modulus = AX25_MODULUS;
482 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
487 * Fill in a created AX.25 created control block with the default
488 * values for a particular device.
490 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
492 ax25->ax25_dev = ax25_dev;
494 if (ax25->ax25_dev != NULL) {
495 ax25_fillin_cb_from_dev(ax25, ax25_dev);
500 * No device, use kernel / AX.25 spec default values
502 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
503 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
504 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
505 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
506 ax25->n2 = AX25_DEF_N2;
507 ax25->paclen = AX25_DEF_PACLEN;
508 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
509 ax25->backoff = AX25_DEF_BACKOFF;
511 if (AX25_DEF_AXDEFMODE) {
512 ax25->modulus = AX25_EMODULUS;
513 ax25->window = AX25_DEF_EWINDOW;
515 ax25->modulus = AX25_MODULUS;
516 ax25->window = AX25_DEF_WINDOW;
521 * Create an empty AX.25 control block.
523 ax25_cb *ax25_create_cb(void)
527 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
530 refcount_set(&ax25->refcount, 1);
532 skb_queue_head_init(&ax25->write_queue);
533 skb_queue_head_init(&ax25->frag_queue);
534 skb_queue_head_init(&ax25->ack_queue);
535 skb_queue_head_init(&ax25->reseq_queue);
537 ax25_setup_timers(ax25);
539 ax25_fillin_cb(ax25, NULL);
541 ax25->state = AX25_STATE_0;
547 * Handling for system calls applied via the various interfaces to an
551 static int ax25_setsockopt(struct socket *sock, int level, int optname,
552 char __user *optval, unsigned int optlen)
554 struct sock *sk = sock->sk;
556 struct net_device *dev;
557 char devname[IFNAMSIZ];
561 if (level != SOL_AX25)
564 if (optlen < sizeof(unsigned int))
567 if (get_user(opt, (unsigned int __user *)optval))
571 ax25 = sk_to_ax25(sk);
575 if (ax25->modulus == AX25_MODULUS) {
576 if (opt < 1 || opt > 7) {
581 if (opt < 1 || opt > 63) {
590 if (opt < 1 || opt > ULONG_MAX / HZ) {
594 ax25->rtt = (opt * HZ) >> 1;
599 if (opt < 1 || opt > ULONG_MAX / HZ) {
607 if (opt < 1 || opt > 31) {
615 if (opt < 1 || opt > ULONG_MAX / HZ) {
623 if (opt > ULONG_MAX / (60 * HZ)) {
627 ax25->idle = opt * 60 * HZ;
639 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
643 ax25->pidincl = opt ? 1 : 0;
647 ax25->iamdigi = opt ? 1 : 0;
651 if (opt < 16 || opt > 65535) {
658 case SO_BINDTODEVICE:
659 if (optlen > IFNAMSIZ - 1)
660 optlen = IFNAMSIZ - 1;
662 memset(devname, 0, sizeof(devname));
664 if (copy_from_user(devname, optval, optlen)) {
669 if (sk->sk_type == SOCK_SEQPACKET &&
670 (sock->state != SS_UNCONNECTED ||
671 sk->sk_state == TCP_LISTEN)) {
672 res = -EADDRNOTAVAIL;
677 dev = __dev_get_by_name(&init_net, devname);
684 ax25->ax25_dev = ax25_dev_ax25dev(dev);
685 if (!ax25->ax25_dev) {
690 ax25_fillin_cb(ax25, ax25->ax25_dev);
702 static int ax25_getsockopt(struct socket *sock, int level, int optname,
703 char __user *optval, int __user *optlen)
705 struct sock *sk = sock->sk;
707 struct ax25_dev *ax25_dev;
708 char devname[IFNAMSIZ];
713 if (level != SOL_AX25)
716 if (get_user(maxlen, optlen))
722 valptr = (void *) &val;
723 length = min_t(unsigned int, maxlen, sizeof(int));
726 ax25 = sk_to_ax25(sk);
750 val = ax25->idle / (60 * HZ);
758 val = (ax25->modulus == AX25_EMODULUS);
773 case SO_BINDTODEVICE:
774 ax25_dev = ax25->ax25_dev;
776 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
777 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
778 length = strlen(devname) + 1;
784 valptr = (void *) devname;
793 if (put_user(length, optlen))
796 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
799 static int ax25_listen(struct socket *sock, int backlog)
801 struct sock *sk = sock->sk;
805 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
806 sk->sk_max_ack_backlog = backlog;
807 sk->sk_state = TCP_LISTEN;
819 * XXX: when creating ax25_sock we should update the .obj_size setting
822 static struct proto ax25_proto = {
824 .owner = THIS_MODULE,
825 .obj_size = sizeof(struct ax25_sock),
828 static int ax25_create(struct net *net, struct socket *sock, int protocol,
834 if (protocol < 0 || protocol > SK_PROTOCOL_MAX)
837 if (!net_eq(net, &init_net))
838 return -EAFNOSUPPORT;
840 switch (sock->type) {
842 if (protocol == 0 || protocol == PF_AX25)
843 protocol = AX25_P_TEXT;
849 case PF_AX25: /* For CLX */
850 protocol = AX25_P_TEXT;
863 return -ESOCKTNOSUPPORT;
864 #ifdef CONFIG_NETROM_MODULE
866 if (ax25_protocol_is_registered(AX25_P_NETROM))
867 return -ESOCKTNOSUPPORT;
870 #ifdef CONFIG_ROSE_MODULE
872 if (ax25_protocol_is_registered(AX25_P_ROSE))
873 return -ESOCKTNOSUPPORT;
881 if (!capable(CAP_NET_RAW))
885 return -ESOCKTNOSUPPORT;
888 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
892 ax25 = ax25_sk(sk)->cb = ax25_create_cb();
898 sock_init_data(sock, sk);
900 sk->sk_destruct = ax25_free_sock;
901 sock->ops = &ax25_proto_ops;
902 sk->sk_protocol = protocol;
909 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
912 ax25_cb *ax25, *oax25;
914 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
918 if ((ax25 = ax25_create_cb()) == NULL) {
923 switch (osk->sk_type) {
934 sock_init_data(NULL, sk);
936 sk->sk_type = osk->sk_type;
937 sk->sk_priority = osk->sk_priority;
938 sk->sk_protocol = osk->sk_protocol;
939 sk->sk_rcvbuf = osk->sk_rcvbuf;
940 sk->sk_sndbuf = osk->sk_sndbuf;
941 sk->sk_state = TCP_ESTABLISHED;
942 sock_copy_flags(sk, osk);
944 oax25 = sk_to_ax25(osk);
946 ax25->modulus = oax25->modulus;
947 ax25->backoff = oax25->backoff;
948 ax25->pidincl = oax25->pidincl;
949 ax25->iamdigi = oax25->iamdigi;
950 ax25->rtt = oax25->rtt;
951 ax25->t1 = oax25->t1;
952 ax25->t2 = oax25->t2;
953 ax25->t3 = oax25->t3;
954 ax25->n2 = oax25->n2;
955 ax25->idle = oax25->idle;
956 ax25->paclen = oax25->paclen;
957 ax25->window = oax25->window;
959 ax25->ax25_dev = ax25_dev;
960 ax25->source_addr = oax25->source_addr;
962 if (oax25->digipeat != NULL) {
963 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
965 if (ax25->digipeat == NULL) {
972 ax25_sk(sk)->cb = ax25;
973 sk->sk_destruct = ax25_free_sock;
979 static int ax25_release(struct socket *sock)
981 struct sock *sk = sock->sk;
991 ax25 = sk_to_ax25(sk);
992 ax25_dev = ax25->ax25_dev;
994 if (sk->sk_type == SOCK_SEQPACKET) {
995 switch (ax25->state) {
998 ax25_disconnect(ax25, 0);
1000 ax25_destroy_socket(ax25);
1005 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
1007 ax25_disconnect(ax25, 0);
1009 if (!sock_flag(ax25->sk, SOCK_DESTROY))
1010 ax25_destroy_socket(ax25);
1015 ax25_clear_queues(ax25);
1018 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1019 case AX25_PROTO_STD_SIMPLEX:
1020 case AX25_PROTO_STD_DUPLEX:
1021 ax25_send_control(ax25,
1025 ax25_stop_t2timer(ax25);
1026 ax25_stop_t3timer(ax25);
1027 ax25_stop_idletimer(ax25);
1029 #ifdef CONFIG_AX25_DAMA_SLAVE
1030 case AX25_PROTO_DAMA_SLAVE:
1031 ax25_stop_t3timer(ax25);
1032 ax25_stop_idletimer(ax25);
1036 ax25_calculate_t1(ax25);
1037 ax25_start_t1timer(ax25);
1038 ax25->state = AX25_STATE_2;
1039 sk->sk_state = TCP_CLOSE;
1040 sk->sk_shutdown |= SEND_SHUTDOWN;
1041 sk->sk_state_change(sk);
1042 sock_set_flag(sk, SOCK_DESTROY);
1049 sk->sk_state = TCP_CLOSE;
1050 sk->sk_shutdown |= SEND_SHUTDOWN;
1051 sk->sk_state_change(sk);
1052 ax25_destroy_socket(ax25);
1055 del_timer_sync(&ax25->timer);
1056 del_timer_sync(&ax25->t1timer);
1057 del_timer_sync(&ax25->t2timer);
1058 del_timer_sync(&ax25->t3timer);
1059 del_timer_sync(&ax25->idletimer);
1060 dev_put(ax25_dev->dev);
1061 ax25_dev_put(ax25_dev);
1072 * We support a funny extension here so you can (as root) give any callsign
1073 * digipeated via a local address as source. This hack is obsolete now
1074 * that we've implemented support for SO_BINDTODEVICE. It is however small
1075 * and trivially backward compatible.
1077 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1079 struct sock *sk = sock->sk;
1080 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1081 ax25_dev *ax25_dev = NULL;
1082 ax25_uid_assoc *user;
1087 if (addr_len != sizeof(struct sockaddr_ax25) &&
1088 addr_len != sizeof(struct full_sockaddr_ax25))
1089 /* support for old structure may go away some time
1090 * ax25_bind(): uses old (6 digipeater) socket structure.
1092 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1093 (addr_len > sizeof(struct full_sockaddr_ax25)))
1096 if (addr->fsa_ax25.sax25_family != AF_AX25)
1099 user = ax25_findbyuid(current_euid());
1104 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1107 call = addr->fsa_ax25.sax25_call;
1112 ax25 = sk_to_ax25(sk);
1113 if (!sock_flag(sk, SOCK_ZAPPED)) {
1118 ax25->source_addr = call;
1121 * User already set interface with SO_BINDTODEVICE
1123 if (ax25->ax25_dev != NULL)
1126 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1127 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1128 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1129 err = -EADDRNOTAVAIL;
1133 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1134 err = -EADDRNOTAVAIL;
1140 ax25_fillin_cb(ax25, ax25_dev);
1141 dev_hold(ax25_dev->dev);
1146 sock_reset_flag(sk, SOCK_ZAPPED);
1155 * FIXME: nonblock behaviour looks like it may have a bug.
1157 static int __must_check ax25_connect(struct socket *sock,
1158 struct sockaddr *uaddr, int addr_len, int flags)
1160 struct sock *sk = sock->sk;
1161 ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1162 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1163 ax25_digi *digi = NULL;
1164 int ct = 0, err = 0;
1167 * some sanity checks. code further down depends on this
1170 if (addr_len == sizeof(struct sockaddr_ax25))
1171 /* support for this will go away in early 2.5.x
1172 * ax25_connect(): uses obsolete socket structure
1175 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1176 /* support for old structure may go away some time
1177 * ax25_connect(): uses old (6 digipeater) socket structure.
1179 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1180 (addr_len > sizeof(struct full_sockaddr_ax25)))
1184 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1189 /* deal with restarts */
1190 if (sock->state == SS_CONNECTING) {
1191 switch (sk->sk_state) {
1192 case TCP_SYN_SENT: /* still trying */
1196 case TCP_ESTABLISHED: /* connection established */
1197 sock->state = SS_CONNECTED;
1200 case TCP_CLOSE: /* connection refused */
1201 sock->state = SS_UNCONNECTED;
1202 err = -ECONNREFUSED;
1207 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1208 err = -EISCONN; /* No reconnect on a seqpacket socket */
1212 sk->sk_state = TCP_CLOSE;
1213 sock->state = SS_UNCONNECTED;
1215 kfree(ax25->digipeat);
1216 ax25->digipeat = NULL;
1219 * Handle digi-peaters to be used.
1221 if (addr_len > sizeof(struct sockaddr_ax25) &&
1222 fsa->fsa_ax25.sax25_ndigis != 0) {
1223 /* Valid number of digipeaters ? */
1224 if (fsa->fsa_ax25.sax25_ndigis < 1 ||
1225 fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS ||
1226 addr_len < sizeof(struct sockaddr_ax25) +
1227 sizeof(ax25_address) * fsa->fsa_ax25.sax25_ndigis) {
1232 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1237 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1238 digi->lastrepeat = -1;
1240 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1241 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1242 AX25_HBIT) && ax25->iamdigi) {
1243 digi->repeated[ct] = 1;
1244 digi->lastrepeat = ct;
1246 digi->repeated[ct] = 0;
1248 digi->calls[ct] = fsa->fsa_digipeater[ct];
1254 * Must bind first - autobinding in this may or may not work. If
1255 * the socket is already bound, check to see if the device has
1256 * been filled in, error if it hasn't.
1258 if (sock_flag(sk, SOCK_ZAPPED)) {
1259 /* check if we can remove this feature. It is broken. */
1260 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1262 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1267 ax25_fillin_cb(ax25, ax25->ax25_dev);
1270 if (ax25->ax25_dev == NULL) {
1272 err = -EHOSTUNREACH;
1277 if (sk->sk_type == SOCK_SEQPACKET &&
1278 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1279 ax25->ax25_dev->dev))) {
1281 err = -EADDRINUSE; /* Already such a connection */
1286 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1287 ax25->digipeat = digi;
1289 /* First the easy one */
1290 if (sk->sk_type != SOCK_SEQPACKET) {
1291 sock->state = SS_CONNECTED;
1292 sk->sk_state = TCP_ESTABLISHED;
1296 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1297 sock->state = SS_CONNECTING;
1298 sk->sk_state = TCP_SYN_SENT;
1300 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1301 case AX25_PROTO_STD_SIMPLEX:
1302 case AX25_PROTO_STD_DUPLEX:
1303 ax25_std_establish_data_link(ax25);
1306 #ifdef CONFIG_AX25_DAMA_SLAVE
1307 case AX25_PROTO_DAMA_SLAVE:
1308 ax25->modulus = AX25_MODULUS;
1309 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1310 if (ax25->ax25_dev->dama.slave)
1311 ax25_ds_establish_data_link(ax25);
1313 ax25_std_establish_data_link(ax25);
1318 ax25->state = AX25_STATE_1;
1320 ax25_start_heartbeat(ax25);
1323 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1328 if (sk->sk_state == TCP_SYN_SENT) {
1332 prepare_to_wait(sk_sleep(sk), &wait,
1333 TASK_INTERRUPTIBLE);
1334 if (sk->sk_state != TCP_SYN_SENT)
1336 if (!signal_pending(current)) {
1345 finish_wait(sk_sleep(sk), &wait);
1351 if (sk->sk_state != TCP_ESTABLISHED) {
1352 /* Not in ABM, not in WAIT_UA -> failed */
1353 sock->state = SS_UNCONNECTED;
1354 err = sock_error(sk); /* Always set at this point */
1358 sock->state = SS_CONNECTED;
1367 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags,
1370 struct sk_buff *skb;
1376 if (sock->state != SS_UNCONNECTED)
1379 if ((sk = sock->sk) == NULL)
1383 if (sk->sk_type != SOCK_SEQPACKET) {
1388 if (sk->sk_state != TCP_LISTEN) {
1394 * The read queue this time is holding sockets ready to use
1395 * hooked into the SABM we saved
1398 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1399 skb = skb_dequeue(&sk->sk_receive_queue);
1403 if (flags & O_NONBLOCK) {
1407 if (!signal_pending(current)) {
1416 finish_wait(sk_sleep(sk), &wait);
1422 sock_graft(newsk, newsock);
1424 /* Now attach up the new socket */
1426 sk->sk_ack_backlog--;
1427 newsock->state = SS_CONNECTED;
1435 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1438 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1439 struct sock *sk = sock->sk;
1440 unsigned char ndigi, i;
1444 memset(fsa, 0, sizeof(*fsa));
1446 ax25 = sk_to_ax25(sk);
1449 if (sk->sk_state != TCP_ESTABLISHED) {
1454 fsa->fsa_ax25.sax25_family = AF_AX25;
1455 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1457 if (ax25->digipeat != NULL) {
1458 ndigi = ax25->digipeat->ndigi;
1459 fsa->fsa_ax25.sax25_ndigis = ndigi;
1460 for (i = 0; i < ndigi; i++)
1461 fsa->fsa_digipeater[i] =
1462 ax25->digipeat->calls[i];
1465 fsa->fsa_ax25.sax25_family = AF_AX25;
1466 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1467 fsa->fsa_ax25.sax25_ndigis = 1;
1468 if (ax25->ax25_dev != NULL) {
1469 memcpy(&fsa->fsa_digipeater[0],
1470 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1472 fsa->fsa_digipeater[0] = null_ax25_address;
1475 err = sizeof (struct full_sockaddr_ax25);
1483 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1485 DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1486 struct sock *sk = sock->sk;
1487 struct sockaddr_ax25 sax;
1488 struct sk_buff *skb;
1489 ax25_digi dtmp, *dp;
1492 int lv, err, addr_len = msg->msg_namelen;
1494 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1498 ax25 = sk_to_ax25(sk);
1500 if (sock_flag(sk, SOCK_ZAPPED)) {
1501 err = -EADDRNOTAVAIL;
1505 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1506 send_sig(SIGPIPE, current, 0);
1511 if (ax25->ax25_dev == NULL) {
1516 if (len > ax25->ax25_dev->dev->mtu) {
1522 if (usax->sax25_family != AF_AX25) {
1527 if (addr_len == sizeof(struct sockaddr_ax25))
1528 /* ax25_sendmsg(): uses obsolete socket structure */
1530 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1531 /* support for old structure may go away some time
1532 * ax25_sendmsg(): uses old (6 digipeater)
1535 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1536 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1542 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1544 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1546 /* Valid number of digipeaters ? */
1547 if (usax->sax25_ndigis < 1 ||
1548 usax->sax25_ndigis > AX25_MAX_DIGIS ||
1549 addr_len < sizeof(struct sockaddr_ax25) +
1550 sizeof(ax25_address) * usax->sax25_ndigis) {
1555 dtmp.ndigi = usax->sax25_ndigis;
1557 while (ct < usax->sax25_ndigis) {
1558 dtmp.repeated[ct] = 0;
1559 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1563 dtmp.lastrepeat = 0;
1567 if (sk->sk_type == SOCK_SEQPACKET &&
1568 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1572 if (usax->sax25_ndigis == 0)
1578 * FIXME: 1003.1g - if the socket is like this because
1579 * it has become closed (not started closed) and is VC
1580 * we ought to SIGPIPE, EPIPE
1582 if (sk->sk_state != TCP_ESTABLISHED) {
1586 sax.sax25_family = AF_AX25;
1587 sax.sax25_call = ax25->dest_addr;
1588 dp = ax25->digipeat;
1591 /* Build a packet */
1592 /* Assume the worst case */
1593 size = len + ax25->ax25_dev->dev->hard_header_len;
1595 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1599 skb_reserve(skb, size - len);
1601 /* User data follows immediately after the AX.25 data */
1602 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1608 skb_reset_network_header(skb);
1610 /* Add the PID if one is not supplied by the user in the skb */
1612 *(u8 *)skb_push(skb, 1) = sk->sk_protocol;
1614 if (sk->sk_type == SOCK_SEQPACKET) {
1615 /* Connected mode sockets go via the LAPB machine */
1616 if (sk->sk_state != TCP_ESTABLISHED) {
1622 /* Shove it onto the queue and kick */
1623 ax25_output(ax25, ax25->paclen, skb);
1629 skb_push(skb, 1 + ax25_addr_size(dp));
1631 /* Building AX.25 Header */
1633 /* Build an AX.25 header */
1634 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1635 dp, AX25_COMMAND, AX25_MODULUS);
1637 skb_set_transport_header(skb, lv);
1639 *skb_transport_header(skb) = AX25_UI;
1641 /* Datagram frames go straight out of the door as UI */
1642 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1652 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1655 struct sock *sk = sock->sk;
1656 struct sk_buff *skb;
1662 * This works for seqpacket too. The receiver has ordered the
1663 * queue for us! We do one quick check first though
1665 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1670 /* Now we can treat all alike */
1671 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1672 flags & MSG_DONTWAIT, &err);
1676 if (!sk_to_ax25(sk)->pidincl)
1677 skb_pull(skb, 1); /* Remove PID */
1679 skb_reset_transport_header(skb);
1682 if (copied > size) {
1684 msg->msg_flags |= MSG_TRUNC;
1687 skb_copy_datagram_msg(skb, 0, msg, copied);
1689 if (msg->msg_name) {
1692 const unsigned char *mac = skb_mac_header(skb);
1693 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1695 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1696 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1698 sax->sax25_family = AF_AX25;
1699 /* We set this correctly, even though we may not let the
1700 application know the digi calls further down (because it
1701 did NOT ask to know them). This could get political... **/
1702 sax->sax25_ndigis = digi.ndigi;
1703 sax->sax25_call = src;
1705 if (sax->sax25_ndigis != 0) {
1707 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1709 for (ct = 0; ct < digi.ndigi; ct++)
1710 fsa->fsa_digipeater[ct] = digi.calls[ct];
1712 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1715 skb_free_datagram(sk, skb);
1724 static int ax25_shutdown(struct socket *sk, int how)
1726 /* FIXME - generate DM and RNR states */
1730 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1732 struct sock *sk = sock->sk;
1733 void __user *argp = (void __user *)arg;
1741 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1744 res = put_user(amount, (int __user *)argp);
1749 struct sk_buff *skb;
1751 /* These two are safe on a single CPU system as only user tasks fiddle here */
1752 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1754 res = put_user(amount, (int __user *) argp);
1758 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1759 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1760 case SIOCAX25GETUID: {
1761 struct sockaddr_ax25 sax25;
1762 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1766 res = ax25_uid_ioctl(cmd, &sax25);
1770 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1772 if (!capable(CAP_NET_ADMIN)) {
1776 if (get_user(amount, (long __user *)argp)) {
1780 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1784 ax25_uid_policy = amount;
1792 if (!capable(CAP_NET_ADMIN)) {
1796 res = ax25_rt_ioctl(cmd, argp);
1799 case SIOCAX25CTLCON:
1800 if (!capable(CAP_NET_ADMIN)) {
1804 res = ax25_ctl_ioctl(cmd, argp);
1807 case SIOCAX25GETINFO:
1808 case SIOCAX25GETINFOOLD: {
1809 ax25_cb *ax25 = sk_to_ax25(sk);
1810 struct ax25_info_struct ax25_info;
1812 ax25_info.t1 = ax25->t1 / HZ;
1813 ax25_info.t2 = ax25->t2 / HZ;
1814 ax25_info.t3 = ax25->t3 / HZ;
1815 ax25_info.idle = ax25->idle / (60 * HZ);
1816 ax25_info.n2 = ax25->n2;
1817 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1818 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1819 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1820 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1821 ax25_info.n2count = ax25->n2count;
1822 ax25_info.state = ax25->state;
1823 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1824 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1825 ax25_info.vs = ax25->vs;
1826 ax25_info.vr = ax25->vr;
1827 ax25_info.va = ax25->va;
1828 ax25_info.vs_max = ax25->vs; /* reserved */
1829 ax25_info.paclen = ax25->paclen;
1830 ax25_info.window = ax25->window;
1832 /* old structure? */
1833 if (cmd == SIOCAX25GETINFOOLD) {
1834 static int warned = 0;
1836 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1841 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1846 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1855 case SIOCAX25ADDFWD:
1856 case SIOCAX25DELFWD: {
1857 struct ax25_fwd_struct ax25_fwd;
1858 if (!capable(CAP_NET_ADMIN)) {
1862 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1866 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1872 case SIOCGIFDSTADDR:
1873 case SIOCSIFDSTADDR:
1874 case SIOCGIFBRDADDR:
1875 case SIOCSIFBRDADDR:
1876 case SIOCGIFNETMASK:
1877 case SIOCSIFNETMASK:
1892 #ifdef CONFIG_PROC_FS
1894 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1895 __acquires(ax25_list_lock)
1897 spin_lock_bh(&ax25_list_lock);
1898 return seq_hlist_start(&ax25_list, *pos);
1901 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1903 return seq_hlist_next(v, &ax25_list, pos);
1906 static void ax25_info_stop(struct seq_file *seq, void *v)
1907 __releases(ax25_list_lock)
1909 spin_unlock_bh(&ax25_list_lock);
1912 static int ax25_info_show(struct seq_file *seq, void *v)
1914 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1921 * 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
1924 seq_printf(seq, "%p %s %s%s ",
1926 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1927 ax2asc(buf, &ax25->source_addr),
1928 ax25->iamdigi? "*":"");
1929 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1931 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1932 seq_printf(seq, ",%s%s",
1933 ax2asc(buf, &ax25->digipeat->calls[k]),
1934 ax25->digipeat->repeated[k]? "*":"");
1937 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1939 ax25->vs, ax25->vr, ax25->va,
1940 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1941 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1942 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1943 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1944 ax25->idle / (60 * HZ),
1945 ax25->n2count, ax25->n2,
1950 if (ax25->sk != NULL) {
1951 seq_printf(seq, " %d %d %lu\n",
1952 sk_wmem_alloc_get(ax25->sk),
1953 sk_rmem_alloc_get(ax25->sk),
1954 sock_i_ino(ax25->sk));
1956 seq_puts(seq, " * * *\n");
1961 static const struct seq_operations ax25_info_seqops = {
1962 .start = ax25_info_start,
1963 .next = ax25_info_next,
1964 .stop = ax25_info_stop,
1965 .show = ax25_info_show,
1969 static const struct net_proto_family ax25_family_ops = {
1971 .create = ax25_create,
1972 .owner = THIS_MODULE,
1975 static const struct proto_ops ax25_proto_ops = {
1977 .owner = THIS_MODULE,
1978 .release = ax25_release,
1980 .connect = ax25_connect,
1981 .socketpair = sock_no_socketpair,
1982 .accept = ax25_accept,
1983 .getname = ax25_getname,
1984 .poll = datagram_poll,
1985 .ioctl = ax25_ioctl,
1986 .gettstamp = sock_gettstamp,
1987 .listen = ax25_listen,
1988 .shutdown = ax25_shutdown,
1989 .setsockopt = ax25_setsockopt,
1990 .getsockopt = ax25_getsockopt,
1991 .sendmsg = ax25_sendmsg,
1992 .recvmsg = ax25_recvmsg,
1993 .mmap = sock_no_mmap,
1994 .sendpage = sock_no_sendpage,
1998 * Called by socket.c on kernel start up
2000 static struct packet_type ax25_packet_type __read_mostly = {
2001 .type = cpu_to_be16(ETH_P_AX25),
2002 .func = ax25_kiss_rcv,
2005 static struct notifier_block ax25_dev_notifier = {
2006 .notifier_call = ax25_device_event,
2009 static int __init ax25_init(void)
2011 int rc = proto_register(&ax25_proto, 0);
2016 sock_register(&ax25_family_ops);
2017 dev_add_pack(&ax25_packet_type);
2018 register_netdevice_notifier(&ax25_dev_notifier);
2020 proc_create_seq("ax25_route", 0444, init_net.proc_net, &ax25_rt_seqops);
2021 proc_create_seq("ax25", 0444, init_net.proc_net, &ax25_info_seqops);
2022 proc_create_seq("ax25_calls", 0444, init_net.proc_net,
2027 module_init(ax25_init);
2030 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2031 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2032 MODULE_LICENSE("GPL");
2033 MODULE_ALIAS_NETPROTO(PF_AX25);
2035 static void __exit ax25_exit(void)
2037 remove_proc_entry("ax25_route", init_net.proc_net);
2038 remove_proc_entry("ax25", init_net.proc_net);
2039 remove_proc_entry("ax25_calls", init_net.proc_net);
2041 unregister_netdevice_notifier(&ax25_dev_notifier);
2043 dev_remove_pack(&ax25_packet_type);
2045 sock_unregister(PF_AX25);
2046 proto_unregister(&ax25_proto);
2052 module_exit(ax25_exit);