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 spin_lock_bh(&ax25_list_lock);
66 if (!hlist_unhashed(&ax25->ax25_node)) {
67 hlist_del_init(&ax25->ax25_node);
70 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)
84 ax25_dev->device_up = false;
86 spin_lock_bh(&ax25_list_lock);
88 ax25_for_each(s, &ax25_list) {
89 if (s->ax25_dev == ax25_dev) {
92 spin_unlock_bh(&ax25_list_lock);
93 ax25_disconnect(s, ENETUNREACH);
96 spin_lock_bh(&ax25_list_lock);
100 spin_unlock_bh(&ax25_list_lock);
102 ax25_disconnect(s, ENETUNREACH);
105 dev_put(ax25_dev->dev);
106 ax25_dev_put(ax25_dev);
110 spin_lock_bh(&ax25_list_lock);
112 /* The entry could have been deleted from the
113 * list meanwhile and thus the next pointer is
114 * no longer valid. Play it safe and restart
115 * the scan. Forward progress is ensured
116 * because we set s->ax25_dev to NULL and we
117 * are never passed a NULL 'dev' argument.
122 spin_unlock_bh(&ax25_list_lock);
126 * Handle device status changes.
128 static int ax25_device_event(struct notifier_block *this, unsigned long event,
131 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
133 if (!net_eq(dev_net(dev), &init_net))
136 /* Reject non AX.25 devices */
137 if (dev->type != ARPHRD_AX25)
142 ax25_dev_device_up(dev);
145 ax25_kill_by_device(dev);
146 ax25_rt_device_down(dev);
147 ax25_dev_device_down(dev);
157 * Add a socket to the bound sockets list.
159 void ax25_cb_add(ax25_cb *ax25)
161 spin_lock_bh(&ax25_list_lock);
163 hlist_add_head(&ax25->ax25_node, &ax25_list);
164 spin_unlock_bh(&ax25_list_lock);
168 * Find a socket that wants to accept the SABM we have just
171 struct sock *ax25_find_listener(ax25_address *addr, int digi,
172 struct net_device *dev, int type)
176 spin_lock(&ax25_list_lock);
177 ax25_for_each(s, &ax25_list) {
178 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
180 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
181 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
182 /* If device is null we match any device */
183 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
185 spin_unlock(&ax25_list_lock);
190 spin_unlock(&ax25_list_lock);
196 * Find an AX.25 socket given both ends.
198 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
201 struct sock *sk = NULL;
204 spin_lock(&ax25_list_lock);
205 ax25_for_each(s, &ax25_list) {
206 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
207 !ax25cmp(&s->dest_addr, dest_addr) &&
208 s->sk->sk_type == type) {
215 spin_unlock(&ax25_list_lock);
221 * Find an AX.25 control block given both ends. It will only pick up
222 * floating AX.25 control blocks or non Raw socket bound control blocks.
224 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
225 ax25_digi *digi, struct net_device *dev)
229 spin_lock_bh(&ax25_list_lock);
230 ax25_for_each(s, &ax25_list) {
231 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
233 if (s->ax25_dev == NULL)
235 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
236 if (digi != NULL && digi->ndigi != 0) {
237 if (s->digipeat == NULL)
239 if (ax25digicmp(s->digipeat, digi) != 0)
242 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
246 spin_unlock_bh(&ax25_list_lock);
251 spin_unlock_bh(&ax25_list_lock);
256 EXPORT_SYMBOL(ax25_find_cb);
258 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
261 struct sk_buff *copy;
263 spin_lock(&ax25_list_lock);
264 ax25_for_each(s, &ax25_list) {
265 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
266 s->sk->sk_type == SOCK_RAW &&
267 s->sk->sk_protocol == proto &&
268 s->ax25_dev->dev == skb->dev &&
269 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
270 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
272 if (sock_queue_rcv_skb(s->sk, copy) != 0)
276 spin_unlock(&ax25_list_lock);
282 void ax25_destroy_socket(ax25_cb *);
285 * Handler for deferred kills.
287 static void ax25_destroy_timer(struct timer_list *t)
289 ax25_cb *ax25 = from_timer(ax25, t, dtimer);
296 ax25_destroy_socket(ax25);
302 * This is called from user mode and the timers. Thus it protects itself
303 * against interrupt users but doesn't worry about being called during
304 * work. Once it is removed from the queue no interrupt or bottom half
305 * will touch it and we are (fairly 8-) ) safe.
307 void ax25_destroy_socket(ax25_cb *ax25)
313 ax25_stop_heartbeat(ax25);
314 ax25_stop_t1timer(ax25);
315 ax25_stop_t2timer(ax25);
316 ax25_stop_t3timer(ax25);
317 ax25_stop_idletimer(ax25);
319 ax25_clear_queues(ax25); /* Flush the queues */
321 if (ax25->sk != NULL) {
322 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
323 if (skb->sk != ax25->sk) {
324 /* A pending connection */
325 ax25_cb *sax25 = sk_to_ax25(skb->sk);
327 /* Queue the unaccepted socket for death */
328 sock_orphan(skb->sk);
330 /* 9A4GL: hack to release unaccepted sockets */
331 skb->sk->sk_state = TCP_LISTEN;
333 ax25_start_heartbeat(sax25);
334 sax25->state = AX25_STATE_0;
339 skb_queue_purge(&ax25->sk->sk_write_queue);
342 if (ax25->sk != NULL) {
343 if (sk_has_allocations(ax25->sk)) {
344 /* Defer: outstanding buffers */
345 timer_setup(&ax25->dtimer, ax25_destroy_timer, 0);
346 ax25->dtimer.expires = jiffies + 2 * HZ;
347 add_timer(&ax25->dtimer);
349 struct sock *sk=ax25->sk;
359 * dl1bke 960311: set parameters for existing AX.25 connections,
360 * includes a KILL command to abort any connection.
361 * VERY useful for debugging ;-)
363 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
365 struct ax25_ctl_struct ax25_ctl;
372 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
375 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
378 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
381 ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr);
385 digi.ndigi = ax25_ctl.digi_count;
386 for (k = 0; k < digi.ndigi; k++)
387 digi.calls[k] = ax25_ctl.digi_addr[k];
389 ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev);
391 ax25_dev_put(ax25_dev);
395 switch (ax25_ctl.cmd) {
397 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
398 #ifdef CONFIG_AX25_DAMA_SLAVE
399 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
402 ax25_disconnect(ax25, ENETRESET);
406 if (ax25->modulus == AX25_MODULUS) {
407 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
410 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
413 ax25->window = ax25_ctl.arg;
417 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
419 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
420 ax25->t1 = ax25_ctl.arg * HZ;
424 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
426 ax25->t2 = ax25_ctl.arg * HZ;
430 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
433 ax25->n2 = ax25_ctl.arg;
437 if (ax25_ctl.arg > ULONG_MAX / HZ)
439 ax25->t3 = ax25_ctl.arg * HZ;
443 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
446 ax25->idle = ax25_ctl.arg * 60 * HZ;
450 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
452 ax25->paclen = ax25_ctl.arg;
460 ax25_dev_put(ax25_dev);
469 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
471 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
472 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
473 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
474 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
475 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
476 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
477 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
478 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
480 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
481 ax25->modulus = AX25_EMODULUS;
482 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
484 ax25->modulus = AX25_MODULUS;
485 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
490 * Fill in a created AX.25 created control block with the default
491 * values for a particular device.
493 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
495 ax25->ax25_dev = ax25_dev;
497 if (ax25->ax25_dev != NULL) {
498 ax25_fillin_cb_from_dev(ax25, ax25_dev);
503 * No device, use kernel / AX.25 spec default values
505 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
506 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
507 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
508 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
509 ax25->n2 = AX25_DEF_N2;
510 ax25->paclen = AX25_DEF_PACLEN;
511 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
512 ax25->backoff = AX25_DEF_BACKOFF;
514 if (AX25_DEF_AXDEFMODE) {
515 ax25->modulus = AX25_EMODULUS;
516 ax25->window = AX25_DEF_EWINDOW;
518 ax25->modulus = AX25_MODULUS;
519 ax25->window = AX25_DEF_WINDOW;
524 * Create an empty AX.25 control block.
526 ax25_cb *ax25_create_cb(void)
530 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
533 refcount_set(&ax25->refcount, 1);
535 skb_queue_head_init(&ax25->write_queue);
536 skb_queue_head_init(&ax25->frag_queue);
537 skb_queue_head_init(&ax25->ack_queue);
538 skb_queue_head_init(&ax25->reseq_queue);
540 ax25_setup_timers(ax25);
542 ax25_fillin_cb(ax25, NULL);
544 ax25->state = AX25_STATE_0;
550 * Handling for system calls applied via the various interfaces to an
554 static int ax25_setsockopt(struct socket *sock, int level, int optname,
555 sockptr_t optval, unsigned int optlen)
557 struct sock *sk = sock->sk;
559 struct net_device *dev;
560 char devname[IFNAMSIZ];
564 if (level != SOL_AX25)
567 if (optlen < sizeof(unsigned int))
570 if (copy_from_sockptr(&opt, optval, sizeof(unsigned int)))
574 ax25 = sk_to_ax25(sk);
578 if (ax25->modulus == AX25_MODULUS) {
579 if (opt < 1 || opt > 7) {
584 if (opt < 1 || opt > 63) {
593 if (opt < 1 || opt > UINT_MAX / HZ) {
597 ax25->rtt = (opt * HZ) >> 1;
602 if (opt < 1 || opt > UINT_MAX / HZ) {
610 if (opt < 1 || opt > 31) {
618 if (opt < 1 || opt > UINT_MAX / HZ) {
626 if (opt > UINT_MAX / (60 * HZ)) {
630 ax25->idle = opt * 60 * HZ;
642 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
646 ax25->pidincl = opt ? 1 : 0;
650 ax25->iamdigi = opt ? 1 : 0;
654 if (opt < 16 || opt > 65535) {
661 case SO_BINDTODEVICE:
662 if (optlen > IFNAMSIZ - 1)
663 optlen = IFNAMSIZ - 1;
665 memset(devname, 0, sizeof(devname));
667 if (copy_from_sockptr(devname, optval, optlen)) {
672 if (sk->sk_type == SOCK_SEQPACKET &&
673 (sock->state != SS_UNCONNECTED ||
674 sk->sk_state == TCP_LISTEN)) {
675 res = -EADDRNOTAVAIL;
680 dev = __dev_get_by_name(&init_net, devname);
687 ax25->ax25_dev = ax25_dev_ax25dev(dev);
688 if (!ax25->ax25_dev) {
693 ax25_fillin_cb(ax25, ax25->ax25_dev);
705 static int ax25_getsockopt(struct socket *sock, int level, int optname,
706 char __user *optval, int __user *optlen)
708 struct sock *sk = sock->sk;
710 struct ax25_dev *ax25_dev;
711 char devname[IFNAMSIZ];
716 if (level != SOL_AX25)
719 if (get_user(maxlen, optlen))
725 valptr = (void *) &val;
726 length = min_t(unsigned int, maxlen, sizeof(int));
729 ax25 = sk_to_ax25(sk);
753 val = ax25->idle / (60 * HZ);
761 val = (ax25->modulus == AX25_EMODULUS);
776 case SO_BINDTODEVICE:
777 ax25_dev = ax25->ax25_dev;
779 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
780 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
781 length = strlen(devname) + 1;
787 valptr = (void *) devname;
796 if (put_user(length, optlen))
799 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
802 static int ax25_listen(struct socket *sock, int backlog)
804 struct sock *sk = sock->sk;
808 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
809 sk->sk_max_ack_backlog = backlog;
810 sk->sk_state = TCP_LISTEN;
822 * XXX: when creating ax25_sock we should update the .obj_size setting
825 static struct proto ax25_proto = {
827 .owner = THIS_MODULE,
828 .obj_size = sizeof(struct ax25_sock),
831 static int ax25_create(struct net *net, struct socket *sock, int protocol,
837 if (protocol < 0 || protocol > U8_MAX)
840 if (!net_eq(net, &init_net))
841 return -EAFNOSUPPORT;
843 switch (sock->type) {
845 if (protocol == 0 || protocol == PF_AX25)
846 protocol = AX25_P_TEXT;
852 case PF_AX25: /* For CLX */
853 protocol = AX25_P_TEXT;
866 return -ESOCKTNOSUPPORT;
867 #ifdef CONFIG_NETROM_MODULE
869 if (ax25_protocol_is_registered(AX25_P_NETROM))
870 return -ESOCKTNOSUPPORT;
873 #ifdef CONFIG_ROSE_MODULE
875 if (ax25_protocol_is_registered(AX25_P_ROSE))
876 return -ESOCKTNOSUPPORT;
885 if (!capable(CAP_NET_RAW))
889 return -ESOCKTNOSUPPORT;
892 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
896 ax25 = ax25_sk(sk)->cb = ax25_create_cb();
902 sock_init_data(sock, sk);
904 sk->sk_destruct = ax25_free_sock;
905 sock->ops = &ax25_proto_ops;
906 sk->sk_protocol = protocol;
913 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
916 ax25_cb *ax25, *oax25;
918 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
922 if ((ax25 = ax25_create_cb()) == NULL) {
927 switch (osk->sk_type) {
938 sock_init_data(NULL, sk);
940 sk->sk_type = osk->sk_type;
941 sk->sk_priority = osk->sk_priority;
942 sk->sk_protocol = osk->sk_protocol;
943 sk->sk_rcvbuf = osk->sk_rcvbuf;
944 sk->sk_sndbuf = osk->sk_sndbuf;
945 sk->sk_state = TCP_ESTABLISHED;
946 sock_copy_flags(sk, osk);
948 oax25 = sk_to_ax25(osk);
950 ax25->modulus = oax25->modulus;
951 ax25->backoff = oax25->backoff;
952 ax25->pidincl = oax25->pidincl;
953 ax25->iamdigi = oax25->iamdigi;
954 ax25->rtt = oax25->rtt;
955 ax25->t1 = oax25->t1;
956 ax25->t2 = oax25->t2;
957 ax25->t3 = oax25->t3;
958 ax25->n2 = oax25->n2;
959 ax25->idle = oax25->idle;
960 ax25->paclen = oax25->paclen;
961 ax25->window = oax25->window;
963 ax25->ax25_dev = ax25_dev;
964 ax25->source_addr = oax25->source_addr;
966 if (oax25->digipeat != NULL) {
967 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
969 if (ax25->digipeat == NULL) {
976 ax25_sk(sk)->cb = ax25;
977 sk->sk_destruct = ax25_free_sock;
983 static int ax25_release(struct socket *sock)
985 struct sock *sk = sock->sk;
995 ax25 = sk_to_ax25(sk);
996 ax25_dev = ax25->ax25_dev;
998 if (sk->sk_type == SOCK_SEQPACKET) {
999 switch (ax25->state) {
1001 if (!sock_flag(ax25->sk, SOCK_DEAD)) {
1003 ax25_disconnect(ax25, 0);
1006 ax25_destroy_socket(ax25);
1011 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
1013 ax25_disconnect(ax25, 0);
1015 if (!sock_flag(ax25->sk, SOCK_DESTROY))
1016 ax25_destroy_socket(ax25);
1021 ax25_clear_queues(ax25);
1024 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1025 case AX25_PROTO_STD_SIMPLEX:
1026 case AX25_PROTO_STD_DUPLEX:
1027 ax25_send_control(ax25,
1031 ax25_stop_t2timer(ax25);
1032 ax25_stop_t3timer(ax25);
1033 ax25_stop_idletimer(ax25);
1035 #ifdef CONFIG_AX25_DAMA_SLAVE
1036 case AX25_PROTO_DAMA_SLAVE:
1037 ax25_stop_t3timer(ax25);
1038 ax25_stop_idletimer(ax25);
1042 ax25_calculate_t1(ax25);
1043 ax25_start_t1timer(ax25);
1044 ax25->state = AX25_STATE_2;
1045 sk->sk_state = TCP_CLOSE;
1046 sk->sk_shutdown |= SEND_SHUTDOWN;
1047 sk->sk_state_change(sk);
1048 sock_set_flag(sk, SOCK_DESTROY);
1055 sk->sk_state = TCP_CLOSE;
1056 sk->sk_shutdown |= SEND_SHUTDOWN;
1057 sk->sk_state_change(sk);
1058 ax25_destroy_socket(ax25);
1061 if (!ax25_dev->device_up) {
1062 del_timer_sync(&ax25->timer);
1063 del_timer_sync(&ax25->t1timer);
1064 del_timer_sync(&ax25->t2timer);
1065 del_timer_sync(&ax25->t3timer);
1066 del_timer_sync(&ax25->idletimer);
1068 dev_put(ax25_dev->dev);
1069 ax25_dev_put(ax25_dev);
1080 * We support a funny extension here so you can (as root) give any callsign
1081 * digipeated via a local address as source. This hack is obsolete now
1082 * that we've implemented support for SO_BINDTODEVICE. It is however small
1083 * and trivially backward compatible.
1085 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1087 struct sock *sk = sock->sk;
1088 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1089 ax25_dev *ax25_dev = NULL;
1090 ax25_uid_assoc *user;
1095 if (addr_len != sizeof(struct sockaddr_ax25) &&
1096 addr_len != sizeof(struct full_sockaddr_ax25))
1097 /* support for old structure may go away some time
1098 * ax25_bind(): uses old (6 digipeater) socket structure.
1100 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1101 (addr_len > sizeof(struct full_sockaddr_ax25)))
1104 if (addr->fsa_ax25.sax25_family != AF_AX25)
1107 user = ax25_findbyuid(current_euid());
1112 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1115 call = addr->fsa_ax25.sax25_call;
1120 ax25 = sk_to_ax25(sk);
1121 if (!sock_flag(sk, SOCK_ZAPPED)) {
1126 ax25->source_addr = call;
1129 * User already set interface with SO_BINDTODEVICE
1131 if (ax25->ax25_dev != NULL)
1134 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1135 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1136 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1137 err = -EADDRNOTAVAIL;
1141 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1142 err = -EADDRNOTAVAIL;
1148 ax25_fillin_cb(ax25, ax25_dev);
1149 dev_hold(ax25_dev->dev);
1154 sock_reset_flag(sk, SOCK_ZAPPED);
1163 * FIXME: nonblock behaviour looks like it may have a bug.
1165 static int __must_check ax25_connect(struct socket *sock,
1166 struct sockaddr *uaddr, int addr_len, int flags)
1168 struct sock *sk = sock->sk;
1169 ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1170 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1171 ax25_digi *digi = NULL;
1172 int ct = 0, err = 0;
1175 * some sanity checks. code further down depends on this
1178 if (addr_len == sizeof(struct sockaddr_ax25))
1179 /* support for this will go away in early 2.5.x
1180 * ax25_connect(): uses obsolete socket structure
1183 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1184 /* support for old structure may go away some time
1185 * ax25_connect(): uses old (6 digipeater) socket structure.
1187 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1188 (addr_len > sizeof(struct full_sockaddr_ax25)))
1192 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1197 /* deal with restarts */
1198 if (sock->state == SS_CONNECTING) {
1199 switch (sk->sk_state) {
1200 case TCP_SYN_SENT: /* still trying */
1204 case TCP_ESTABLISHED: /* connection established */
1205 sock->state = SS_CONNECTED;
1208 case TCP_CLOSE: /* connection refused */
1209 sock->state = SS_UNCONNECTED;
1210 err = -ECONNREFUSED;
1215 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1216 err = -EISCONN; /* No reconnect on a seqpacket socket */
1220 sk->sk_state = TCP_CLOSE;
1221 sock->state = SS_UNCONNECTED;
1223 kfree(ax25->digipeat);
1224 ax25->digipeat = NULL;
1227 * Handle digi-peaters to be used.
1229 if (addr_len > sizeof(struct sockaddr_ax25) &&
1230 fsa->fsa_ax25.sax25_ndigis != 0) {
1231 /* Valid number of digipeaters ? */
1232 if (fsa->fsa_ax25.sax25_ndigis < 1 ||
1233 fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS ||
1234 addr_len < sizeof(struct sockaddr_ax25) +
1235 sizeof(ax25_address) * fsa->fsa_ax25.sax25_ndigis) {
1240 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1245 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1246 digi->lastrepeat = -1;
1248 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1249 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1250 AX25_HBIT) && ax25->iamdigi) {
1251 digi->repeated[ct] = 1;
1252 digi->lastrepeat = ct;
1254 digi->repeated[ct] = 0;
1256 digi->calls[ct] = fsa->fsa_digipeater[ct];
1262 * Must bind first - autobinding in this may or may not work. If
1263 * the socket is already bound, check to see if the device has
1264 * been filled in, error if it hasn't.
1266 if (sock_flag(sk, SOCK_ZAPPED)) {
1267 /* check if we can remove this feature. It is broken. */
1268 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1270 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1275 ax25_fillin_cb(ax25, ax25->ax25_dev);
1278 if (ax25->ax25_dev == NULL) {
1280 err = -EHOSTUNREACH;
1285 if (sk->sk_type == SOCK_SEQPACKET &&
1286 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1287 ax25->ax25_dev->dev))) {
1289 err = -EADDRINUSE; /* Already such a connection */
1294 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1295 ax25->digipeat = digi;
1297 /* First the easy one */
1298 if (sk->sk_type != SOCK_SEQPACKET) {
1299 sock->state = SS_CONNECTED;
1300 sk->sk_state = TCP_ESTABLISHED;
1304 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1305 sock->state = SS_CONNECTING;
1306 sk->sk_state = TCP_SYN_SENT;
1308 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1309 case AX25_PROTO_STD_SIMPLEX:
1310 case AX25_PROTO_STD_DUPLEX:
1311 ax25_std_establish_data_link(ax25);
1314 #ifdef CONFIG_AX25_DAMA_SLAVE
1315 case AX25_PROTO_DAMA_SLAVE:
1316 ax25->modulus = AX25_MODULUS;
1317 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1318 if (ax25->ax25_dev->dama.slave)
1319 ax25_ds_establish_data_link(ax25);
1321 ax25_std_establish_data_link(ax25);
1326 ax25->state = AX25_STATE_1;
1328 ax25_start_heartbeat(ax25);
1331 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1336 if (sk->sk_state == TCP_SYN_SENT) {
1340 prepare_to_wait(sk_sleep(sk), &wait,
1341 TASK_INTERRUPTIBLE);
1342 if (sk->sk_state != TCP_SYN_SENT)
1344 if (!signal_pending(current)) {
1353 finish_wait(sk_sleep(sk), &wait);
1359 if (sk->sk_state != TCP_ESTABLISHED) {
1360 /* Not in ABM, not in WAIT_UA -> failed */
1361 sock->state = SS_UNCONNECTED;
1362 err = sock_error(sk); /* Always set at this point */
1366 sock->state = SS_CONNECTED;
1375 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags,
1378 struct sk_buff *skb;
1384 if (sock->state != SS_UNCONNECTED)
1387 if ((sk = sock->sk) == NULL)
1391 if (sk->sk_type != SOCK_SEQPACKET) {
1396 if (sk->sk_state != TCP_LISTEN) {
1402 * The read queue this time is holding sockets ready to use
1403 * hooked into the SABM we saved
1406 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1407 skb = skb_dequeue(&sk->sk_receive_queue);
1411 if (flags & O_NONBLOCK) {
1415 if (!signal_pending(current)) {
1424 finish_wait(sk_sleep(sk), &wait);
1430 sock_graft(newsk, newsock);
1432 /* Now attach up the new socket */
1434 sk_acceptq_removed(sk);
1435 newsock->state = SS_CONNECTED;
1443 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1446 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1447 struct sock *sk = sock->sk;
1448 unsigned char ndigi, i;
1452 memset(fsa, 0, sizeof(*fsa));
1454 ax25 = sk_to_ax25(sk);
1457 if (sk->sk_state != TCP_ESTABLISHED) {
1462 fsa->fsa_ax25.sax25_family = AF_AX25;
1463 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1465 if (ax25->digipeat != NULL) {
1466 ndigi = ax25->digipeat->ndigi;
1467 fsa->fsa_ax25.sax25_ndigis = ndigi;
1468 for (i = 0; i < ndigi; i++)
1469 fsa->fsa_digipeater[i] =
1470 ax25->digipeat->calls[i];
1473 fsa->fsa_ax25.sax25_family = AF_AX25;
1474 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1475 fsa->fsa_ax25.sax25_ndigis = 1;
1476 if (ax25->ax25_dev != NULL) {
1477 memcpy(&fsa->fsa_digipeater[0],
1478 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1480 fsa->fsa_digipeater[0] = null_ax25_address;
1483 err = sizeof (struct full_sockaddr_ax25);
1491 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1493 DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1494 struct sock *sk = sock->sk;
1495 struct sockaddr_ax25 sax;
1496 struct sk_buff *skb;
1497 ax25_digi dtmp, *dp;
1500 int lv, err, addr_len = msg->msg_namelen;
1502 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1506 ax25 = sk_to_ax25(sk);
1508 if (sock_flag(sk, SOCK_ZAPPED)) {
1509 err = -EADDRNOTAVAIL;
1513 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1514 send_sig(SIGPIPE, current, 0);
1519 if (ax25->ax25_dev == NULL) {
1524 if (len > ax25->ax25_dev->dev->mtu) {
1530 if (usax->sax25_family != AF_AX25) {
1535 if (addr_len == sizeof(struct sockaddr_ax25))
1536 /* ax25_sendmsg(): uses obsolete socket structure */
1538 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1539 /* support for old structure may go away some time
1540 * ax25_sendmsg(): uses old (6 digipeater)
1543 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1544 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1550 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1552 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1554 /* Valid number of digipeaters ? */
1555 if (usax->sax25_ndigis < 1 ||
1556 usax->sax25_ndigis > AX25_MAX_DIGIS ||
1557 addr_len < sizeof(struct sockaddr_ax25) +
1558 sizeof(ax25_address) * usax->sax25_ndigis) {
1563 dtmp.ndigi = usax->sax25_ndigis;
1565 while (ct < usax->sax25_ndigis) {
1566 dtmp.repeated[ct] = 0;
1567 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1571 dtmp.lastrepeat = 0;
1575 if (sk->sk_type == SOCK_SEQPACKET &&
1576 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1580 if (usax->sax25_ndigis == 0)
1586 * FIXME: 1003.1g - if the socket is like this because
1587 * it has become closed (not started closed) and is VC
1588 * we ought to SIGPIPE, EPIPE
1590 if (sk->sk_state != TCP_ESTABLISHED) {
1594 sax.sax25_family = AF_AX25;
1595 sax.sax25_call = ax25->dest_addr;
1596 dp = ax25->digipeat;
1599 /* Build a packet */
1600 /* Assume the worst case */
1601 size = len + ax25->ax25_dev->dev->hard_header_len;
1603 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1607 skb_reserve(skb, size - len);
1609 /* User data follows immediately after the AX.25 data */
1610 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1616 skb_reset_network_header(skb);
1618 /* Add the PID if one is not supplied by the user in the skb */
1620 *(u8 *)skb_push(skb, 1) = sk->sk_protocol;
1622 if (sk->sk_type == SOCK_SEQPACKET) {
1623 /* Connected mode sockets go via the LAPB machine */
1624 if (sk->sk_state != TCP_ESTABLISHED) {
1630 /* Shove it onto the queue and kick */
1631 ax25_output(ax25, ax25->paclen, skb);
1637 skb_push(skb, 1 + ax25_addr_size(dp));
1639 /* Building AX.25 Header */
1641 /* Build an AX.25 header */
1642 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1643 dp, AX25_COMMAND, AX25_MODULUS);
1645 skb_set_transport_header(skb, lv);
1647 *skb_transport_header(skb) = AX25_UI;
1649 /* Datagram frames go straight out of the door as UI */
1650 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1660 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1663 struct sock *sk = sock->sk;
1664 struct sk_buff *skb, *last;
1665 struct sk_buff_head *sk_queue;
1673 * This works for seqpacket too. The receiver has ordered the
1674 * queue for us! We do one quick check first though
1676 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1681 /* We need support for non-blocking reads. */
1682 sk_queue = &sk->sk_receive_queue;
1683 skb = __skb_try_recv_datagram(sk, sk_queue, flags, &off, &err, &last);
1684 /* If no packet is available, release_sock(sk) and try again. */
1689 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
1690 while (timeo && !__skb_wait_for_more_packets(sk, sk_queue, &err,
1692 skb = __skb_try_recv_datagram(sk, sk_queue, flags, &off,
1705 if (!sk_to_ax25(sk)->pidincl)
1706 skb_pull(skb, 1); /* Remove PID */
1708 skb_reset_transport_header(skb);
1711 if (copied > size) {
1713 msg->msg_flags |= MSG_TRUNC;
1716 skb_copy_datagram_msg(skb, 0, msg, copied);
1718 if (msg->msg_name) {
1721 const unsigned char *mac = skb_mac_header(skb);
1722 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1724 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1725 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1727 sax->sax25_family = AF_AX25;
1728 /* We set this correctly, even though we may not let the
1729 application know the digi calls further down (because it
1730 did NOT ask to know them). This could get political... **/
1731 sax->sax25_ndigis = digi.ndigi;
1732 sax->sax25_call = src;
1734 if (sax->sax25_ndigis != 0) {
1736 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1738 for (ct = 0; ct < digi.ndigi; ct++)
1739 fsa->fsa_digipeater[ct] = digi.calls[ct];
1741 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1744 skb_free_datagram(sk, skb);
1754 static int ax25_shutdown(struct socket *sk, int how)
1756 /* FIXME - generate DM and RNR states */
1760 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1762 struct sock *sk = sock->sk;
1763 void __user *argp = (void __user *)arg;
1771 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1774 res = put_user(amount, (int __user *)argp);
1779 struct sk_buff *skb;
1781 /* These two are safe on a single CPU system as only user tasks fiddle here */
1782 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1784 res = put_user(amount, (int __user *) argp);
1788 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1789 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1790 case SIOCAX25GETUID: {
1791 struct sockaddr_ax25 sax25;
1792 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1796 res = ax25_uid_ioctl(cmd, &sax25);
1800 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1802 if (!capable(CAP_NET_ADMIN)) {
1806 if (get_user(amount, (long __user *)argp)) {
1810 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1814 ax25_uid_policy = amount;
1822 if (!capable(CAP_NET_ADMIN)) {
1826 res = ax25_rt_ioctl(cmd, argp);
1829 case SIOCAX25CTLCON:
1830 if (!capable(CAP_NET_ADMIN)) {
1834 res = ax25_ctl_ioctl(cmd, argp);
1837 case SIOCAX25GETINFO:
1838 case SIOCAX25GETINFOOLD: {
1839 ax25_cb *ax25 = sk_to_ax25(sk);
1840 struct ax25_info_struct ax25_info;
1842 ax25_info.t1 = ax25->t1 / HZ;
1843 ax25_info.t2 = ax25->t2 / HZ;
1844 ax25_info.t3 = ax25->t3 / HZ;
1845 ax25_info.idle = ax25->idle / (60 * HZ);
1846 ax25_info.n2 = ax25->n2;
1847 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1848 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1849 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1850 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1851 ax25_info.n2count = ax25->n2count;
1852 ax25_info.state = ax25->state;
1853 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1854 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1855 ax25_info.vs = ax25->vs;
1856 ax25_info.vr = ax25->vr;
1857 ax25_info.va = ax25->va;
1858 ax25_info.vs_max = ax25->vs; /* reserved */
1859 ax25_info.paclen = ax25->paclen;
1860 ax25_info.window = ax25->window;
1862 /* old structure? */
1863 if (cmd == SIOCAX25GETINFOOLD) {
1864 static int warned = 0;
1866 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1871 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1876 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1885 case SIOCAX25ADDFWD:
1886 case SIOCAX25DELFWD: {
1887 struct ax25_fwd_struct ax25_fwd;
1888 if (!capable(CAP_NET_ADMIN)) {
1892 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1896 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1902 case SIOCGIFDSTADDR:
1903 case SIOCSIFDSTADDR:
1904 case SIOCGIFBRDADDR:
1905 case SIOCSIFBRDADDR:
1906 case SIOCGIFNETMASK:
1907 case SIOCSIFNETMASK:
1922 #ifdef CONFIG_PROC_FS
1924 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1925 __acquires(ax25_list_lock)
1927 spin_lock_bh(&ax25_list_lock);
1928 return seq_hlist_start(&ax25_list, *pos);
1931 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1933 return seq_hlist_next(v, &ax25_list, pos);
1936 static void ax25_info_stop(struct seq_file *seq, void *v)
1937 __releases(ax25_list_lock)
1939 spin_unlock_bh(&ax25_list_lock);
1942 static int ax25_info_show(struct seq_file *seq, void *v)
1944 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1951 * 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
1954 seq_printf(seq, "%p %s %s%s ",
1956 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1957 ax2asc(buf, &ax25->source_addr),
1958 ax25->iamdigi? "*":"");
1959 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1961 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1962 seq_printf(seq, ",%s%s",
1963 ax2asc(buf, &ax25->digipeat->calls[k]),
1964 ax25->digipeat->repeated[k]? "*":"");
1967 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1969 ax25->vs, ax25->vr, ax25->va,
1970 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1971 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1972 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1973 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1974 ax25->idle / (60 * HZ),
1975 ax25->n2count, ax25->n2,
1980 if (ax25->sk != NULL) {
1981 seq_printf(seq, " %d %d %lu\n",
1982 sk_wmem_alloc_get(ax25->sk),
1983 sk_rmem_alloc_get(ax25->sk),
1984 sock_i_ino(ax25->sk));
1986 seq_puts(seq, " * * *\n");
1991 static const struct seq_operations ax25_info_seqops = {
1992 .start = ax25_info_start,
1993 .next = ax25_info_next,
1994 .stop = ax25_info_stop,
1995 .show = ax25_info_show,
1999 static const struct net_proto_family ax25_family_ops = {
2001 .create = ax25_create,
2002 .owner = THIS_MODULE,
2005 static const struct proto_ops ax25_proto_ops = {
2007 .owner = THIS_MODULE,
2008 .release = ax25_release,
2010 .connect = ax25_connect,
2011 .socketpair = sock_no_socketpair,
2012 .accept = ax25_accept,
2013 .getname = ax25_getname,
2014 .poll = datagram_poll,
2015 .ioctl = ax25_ioctl,
2016 .gettstamp = sock_gettstamp,
2017 .listen = ax25_listen,
2018 .shutdown = ax25_shutdown,
2019 .setsockopt = ax25_setsockopt,
2020 .getsockopt = ax25_getsockopt,
2021 .sendmsg = ax25_sendmsg,
2022 .recvmsg = ax25_recvmsg,
2023 .mmap = sock_no_mmap,
2024 .sendpage = sock_no_sendpage,
2028 * Called by socket.c on kernel start up
2030 static struct packet_type ax25_packet_type __read_mostly = {
2031 .type = cpu_to_be16(ETH_P_AX25),
2032 .func = ax25_kiss_rcv,
2035 static struct notifier_block ax25_dev_notifier = {
2036 .notifier_call = ax25_device_event,
2039 static int __init ax25_init(void)
2041 int rc = proto_register(&ax25_proto, 0);
2046 sock_register(&ax25_family_ops);
2047 dev_add_pack(&ax25_packet_type);
2048 register_netdevice_notifier(&ax25_dev_notifier);
2050 proc_create_seq("ax25_route", 0444, init_net.proc_net, &ax25_rt_seqops);
2051 proc_create_seq("ax25", 0444, init_net.proc_net, &ax25_info_seqops);
2052 proc_create_seq("ax25_calls", 0444, init_net.proc_net,
2057 module_init(ax25_init);
2060 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2061 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2062 MODULE_LICENSE("GPL");
2063 MODULE_ALIAS_NETPROTO(PF_AX25);
2065 static void __exit ax25_exit(void)
2067 remove_proc_entry("ax25_route", init_net.proc_net);
2068 remove_proc_entry("ax25", init_net.proc_net);
2069 remove_proc_entry("ax25_calls", init_net.proc_net);
2071 unregister_netdevice_notifier(&ax25_dev_notifier);
2073 dev_remove_pack(&ax25_packet_type);
2075 sock_unregister(PF_AX25);
2076 proto_unregister(&ax25_proto);
2082 module_exit(ax25_exit);