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/signal.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 <linux/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)
85 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
88 spin_lock_bh(&ax25_list_lock);
90 ax25_for_each(s, &ax25_list) {
91 if (s->ax25_dev == ax25_dev) {
94 spin_unlock_bh(&ax25_list_lock);
95 ax25_disconnect(s, ENETUNREACH);
97 spin_lock_bh(&ax25_list_lock);
101 spin_unlock_bh(&ax25_list_lock);
103 ax25_disconnect(s, ENETUNREACH);
106 dev_put(ax25_dev->dev);
107 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(unsigned long data)
289 ax25_cb *ax25=(ax25_cb *)data;
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 setup_timer(&ax25->dtimer, ax25_destroy_timer,
346 (unsigned long)ax25);
347 ax25->dtimer.expires = jiffies + 2 * HZ;
348 add_timer(&ax25->dtimer);
350 struct sock *sk=ax25->sk;
360 * dl1bke 960311: set parameters for existing AX.25 connections,
361 * includes a KILL command to abort any connection.
362 * VERY useful for debugging ;-)
364 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
366 struct ax25_ctl_struct ax25_ctl;
373 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
376 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
379 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
382 ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr);
386 digi.ndigi = ax25_ctl.digi_count;
387 for (k = 0; k < digi.ndigi; k++)
388 digi.calls[k] = ax25_ctl.digi_addr[k];
390 ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev);
392 ax25_dev_put(ax25_dev);
396 switch (ax25_ctl.cmd) {
398 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
399 #ifdef CONFIG_AX25_DAMA_SLAVE
400 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
403 ax25_disconnect(ax25, ENETRESET);
407 if (ax25->modulus == AX25_MODULUS) {
408 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
411 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
414 ax25->window = ax25_ctl.arg;
418 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
420 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
421 ax25->t1 = ax25_ctl.arg * HZ;
425 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
427 ax25->t2 = ax25_ctl.arg * HZ;
431 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
434 ax25->n2 = ax25_ctl.arg;
438 if (ax25_ctl.arg > ULONG_MAX / HZ)
440 ax25->t3 = ax25_ctl.arg * HZ;
444 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
447 ax25->idle = ax25_ctl.arg * 60 * HZ;
451 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
453 ax25->paclen = ax25_ctl.arg;
461 ax25_dev_put(ax25_dev);
470 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
472 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
473 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
474 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
475 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
476 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
477 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
478 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
479 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
481 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
482 ax25->modulus = AX25_EMODULUS;
483 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
485 ax25->modulus = AX25_MODULUS;
486 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
491 * Fill in a created AX.25 created control block with the default
492 * values for a particular device.
494 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
496 ax25->ax25_dev = ax25_dev;
498 if (ax25->ax25_dev != NULL) {
499 ax25_fillin_cb_from_dev(ax25, ax25_dev);
504 * No device, use kernel / AX.25 spec default values
506 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
507 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
508 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
509 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
510 ax25->n2 = AX25_DEF_N2;
511 ax25->paclen = AX25_DEF_PACLEN;
512 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
513 ax25->backoff = AX25_DEF_BACKOFF;
515 if (AX25_DEF_AXDEFMODE) {
516 ax25->modulus = AX25_EMODULUS;
517 ax25->window = AX25_DEF_EWINDOW;
519 ax25->modulus = AX25_MODULUS;
520 ax25->window = AX25_DEF_WINDOW;
525 * Create an empty AX.25 control block.
527 ax25_cb *ax25_create_cb(void)
531 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
534 refcount_set(&ax25->refcount, 1);
536 skb_queue_head_init(&ax25->write_queue);
537 skb_queue_head_init(&ax25->frag_queue);
538 skb_queue_head_init(&ax25->ack_queue);
539 skb_queue_head_init(&ax25->reseq_queue);
541 ax25_setup_timers(ax25);
543 ax25_fillin_cb(ax25, NULL);
545 ax25->state = AX25_STATE_0;
551 * Handling for system calls applied via the various interfaces to an
555 static int ax25_setsockopt(struct socket *sock, int level, int optname,
556 char __user *optval, unsigned int optlen)
558 struct sock *sk = sock->sk;
560 struct net_device *dev;
561 char devname[IFNAMSIZ];
565 if (level != SOL_AX25)
568 if (optlen < sizeof(unsigned int))
571 if (get_user(opt, (unsigned int __user *)optval))
575 ax25 = sk_to_ax25(sk);
579 if (ax25->modulus == AX25_MODULUS) {
580 if (opt < 1 || opt > 7) {
585 if (opt < 1 || opt > 63) {
594 if (opt < 1 || opt > ULONG_MAX / HZ) {
598 ax25->rtt = (opt * HZ) >> 1;
603 if (opt < 1 || opt > ULONG_MAX / HZ) {
611 if (opt < 1 || opt > 31) {
619 if (opt < 1 || opt > ULONG_MAX / HZ) {
627 if (opt > ULONG_MAX / (60 * HZ)) {
631 ax25->idle = opt * 60 * HZ;
643 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
647 ax25->pidincl = opt ? 1 : 0;
651 ax25->iamdigi = opt ? 1 : 0;
655 if (opt < 16 || opt > 65535) {
662 case SO_BINDTODEVICE:
663 if (optlen > IFNAMSIZ - 1)
664 optlen = IFNAMSIZ - 1;
666 memset(devname, 0, sizeof(devname));
668 if (copy_from_user(devname, optval, optlen)) {
673 if (sk->sk_type == SOCK_SEQPACKET &&
674 (sock->state != SS_UNCONNECTED ||
675 sk->sk_state == TCP_LISTEN)) {
676 res = -EADDRNOTAVAIL;
681 dev = __dev_get_by_name(&init_net, devname);
688 ax25->ax25_dev = ax25_dev_ax25dev(dev);
689 if (!ax25->ax25_dev) {
694 ax25_fillin_cb(ax25, ax25->ax25_dev);
706 static int ax25_getsockopt(struct socket *sock, int level, int optname,
707 char __user *optval, int __user *optlen)
709 struct sock *sk = sock->sk;
711 struct ax25_dev *ax25_dev;
712 char devname[IFNAMSIZ];
717 if (level != SOL_AX25)
720 if (get_user(maxlen, optlen))
726 valptr = (void *) &val;
727 length = min_t(unsigned int, maxlen, sizeof(int));
730 ax25 = sk_to_ax25(sk);
754 val = ax25->idle / (60 * HZ);
762 val = (ax25->modulus == AX25_EMODULUS);
777 case SO_BINDTODEVICE:
778 ax25_dev = ax25->ax25_dev;
780 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
781 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
782 length = strlen(devname) + 1;
788 valptr = (void *) devname;
797 if (put_user(length, optlen))
800 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
803 static int ax25_listen(struct socket *sock, int backlog)
805 struct sock *sk = sock->sk;
809 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
810 sk->sk_max_ack_backlog = backlog;
811 sk->sk_state = TCP_LISTEN;
823 * XXX: when creating ax25_sock we should update the .obj_size setting
826 static struct proto ax25_proto = {
828 .owner = THIS_MODULE,
829 .obj_size = sizeof(struct ax25_sock),
832 static int ax25_create(struct net *net, struct socket *sock, int protocol,
838 if (protocol < 0 || protocol > SK_PROTOCOL_MAX)
841 if (!net_eq(net, &init_net))
842 return -EAFNOSUPPORT;
844 switch (sock->type) {
846 if (protocol == 0 || protocol == PF_AX25)
847 protocol = AX25_P_TEXT;
853 case PF_AX25: /* For CLX */
854 protocol = AX25_P_TEXT;
867 return -ESOCKTNOSUPPORT;
868 #ifdef CONFIG_NETROM_MODULE
870 if (ax25_protocol_is_registered(AX25_P_NETROM))
871 return -ESOCKTNOSUPPORT;
874 #ifdef CONFIG_ROSE_MODULE
876 if (ax25_protocol_is_registered(AX25_P_ROSE))
877 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) {
1002 ax25_disconnect(ax25, 0);
1004 ax25_destroy_socket(ax25);
1009 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
1011 ax25_disconnect(ax25, 0);
1013 if (!sock_flag(ax25->sk, SOCK_DESTROY))
1014 ax25_destroy_socket(ax25);
1019 ax25_clear_queues(ax25);
1022 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1023 case AX25_PROTO_STD_SIMPLEX:
1024 case AX25_PROTO_STD_DUPLEX:
1025 ax25_send_control(ax25,
1029 ax25_stop_t2timer(ax25);
1030 ax25_stop_t3timer(ax25);
1031 ax25_stop_idletimer(ax25);
1033 #ifdef CONFIG_AX25_DAMA_SLAVE
1034 case AX25_PROTO_DAMA_SLAVE:
1035 ax25_stop_t3timer(ax25);
1036 ax25_stop_idletimer(ax25);
1040 ax25_calculate_t1(ax25);
1041 ax25_start_t1timer(ax25);
1042 ax25->state = AX25_STATE_2;
1043 sk->sk_state = TCP_CLOSE;
1044 sk->sk_shutdown |= SEND_SHUTDOWN;
1045 sk->sk_state_change(sk);
1046 sock_set_flag(sk, SOCK_DESTROY);
1053 sk->sk_state = TCP_CLOSE;
1054 sk->sk_shutdown |= SEND_SHUTDOWN;
1055 sk->sk_state_change(sk);
1056 ax25_destroy_socket(ax25);
1059 del_timer_sync(&ax25->timer);
1060 del_timer_sync(&ax25->t1timer);
1061 del_timer_sync(&ax25->t2timer);
1062 del_timer_sync(&ax25->t3timer);
1063 del_timer_sync(&ax25->idletimer);
1064 dev_put(ax25_dev->dev);
1065 ax25_dev_put(ax25_dev);
1076 * We support a funny extension here so you can (as root) give any callsign
1077 * digipeated via a local address as source. This hack is obsolete now
1078 * that we've implemented support for SO_BINDTODEVICE. It is however small
1079 * and trivially backward compatible.
1081 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1083 struct sock *sk = sock->sk;
1084 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1085 ax25_dev *ax25_dev = NULL;
1086 ax25_uid_assoc *user;
1091 if (addr_len != sizeof(struct sockaddr_ax25) &&
1092 addr_len != sizeof(struct full_sockaddr_ax25))
1093 /* support for old structure may go away some time
1094 * ax25_bind(): uses old (6 digipeater) socket structure.
1096 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1097 (addr_len > sizeof(struct full_sockaddr_ax25)))
1100 if (addr->fsa_ax25.sax25_family != AF_AX25)
1103 user = ax25_findbyuid(current_euid());
1108 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1111 call = addr->fsa_ax25.sax25_call;
1116 ax25 = sk_to_ax25(sk);
1117 if (!sock_flag(sk, SOCK_ZAPPED)) {
1122 ax25->source_addr = call;
1125 * User already set interface with SO_BINDTODEVICE
1127 if (ax25->ax25_dev != NULL)
1130 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1131 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1132 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1133 err = -EADDRNOTAVAIL;
1137 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1138 err = -EADDRNOTAVAIL;
1144 ax25_fillin_cb(ax25, ax25_dev);
1145 dev_hold(ax25_dev->dev);
1150 sock_reset_flag(sk, SOCK_ZAPPED);
1159 * FIXME: nonblock behaviour looks like it may have a bug.
1161 static int __must_check ax25_connect(struct socket *sock,
1162 struct sockaddr *uaddr, int addr_len, int flags)
1164 struct sock *sk = sock->sk;
1165 ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1166 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1167 ax25_digi *digi = NULL;
1168 int ct = 0, err = 0;
1171 * some sanity checks. code further down depends on this
1174 if (addr_len == sizeof(struct sockaddr_ax25))
1175 /* support for this will go away in early 2.5.x
1176 * ax25_connect(): uses obsolete socket structure
1179 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1180 /* support for old structure may go away some time
1181 * ax25_connect(): uses old (6 digipeater) socket structure.
1183 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1184 (addr_len > sizeof(struct full_sockaddr_ax25)))
1188 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1193 /* deal with restarts */
1194 if (sock->state == SS_CONNECTING) {
1195 switch (sk->sk_state) {
1196 case TCP_SYN_SENT: /* still trying */
1200 case TCP_ESTABLISHED: /* connection established */
1201 sock->state = SS_CONNECTED;
1204 case TCP_CLOSE: /* connection refused */
1205 sock->state = SS_UNCONNECTED;
1206 err = -ECONNREFUSED;
1211 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1212 err = -EISCONN; /* No reconnect on a seqpacket socket */
1216 sk->sk_state = TCP_CLOSE;
1217 sock->state = SS_UNCONNECTED;
1219 kfree(ax25->digipeat);
1220 ax25->digipeat = NULL;
1223 * Handle digi-peaters to be used.
1225 if (addr_len > sizeof(struct sockaddr_ax25) &&
1226 fsa->fsa_ax25.sax25_ndigis != 0) {
1227 /* Valid number of digipeaters ? */
1228 if (fsa->fsa_ax25.sax25_ndigis < 1 ||
1229 fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS ||
1230 addr_len < sizeof(struct sockaddr_ax25) +
1231 sizeof(ax25_address) * fsa->fsa_ax25.sax25_ndigis) {
1236 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1241 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1242 digi->lastrepeat = -1;
1244 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1245 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1246 AX25_HBIT) && ax25->iamdigi) {
1247 digi->repeated[ct] = 1;
1248 digi->lastrepeat = ct;
1250 digi->repeated[ct] = 0;
1252 digi->calls[ct] = fsa->fsa_digipeater[ct];
1258 * Must bind first - autobinding in this may or may not work. If
1259 * the socket is already bound, check to see if the device has
1260 * been filled in, error if it hasn't.
1262 if (sock_flag(sk, SOCK_ZAPPED)) {
1263 /* check if we can remove this feature. It is broken. */
1264 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1266 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1271 ax25_fillin_cb(ax25, ax25->ax25_dev);
1274 if (ax25->ax25_dev == NULL) {
1276 err = -EHOSTUNREACH;
1281 if (sk->sk_type == SOCK_SEQPACKET &&
1282 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1283 ax25->ax25_dev->dev))) {
1285 err = -EADDRINUSE; /* Already such a connection */
1290 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1291 ax25->digipeat = digi;
1293 /* First the easy one */
1294 if (sk->sk_type != SOCK_SEQPACKET) {
1295 sock->state = SS_CONNECTED;
1296 sk->sk_state = TCP_ESTABLISHED;
1300 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1301 sock->state = SS_CONNECTING;
1302 sk->sk_state = TCP_SYN_SENT;
1304 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1305 case AX25_PROTO_STD_SIMPLEX:
1306 case AX25_PROTO_STD_DUPLEX:
1307 ax25_std_establish_data_link(ax25);
1310 #ifdef CONFIG_AX25_DAMA_SLAVE
1311 case AX25_PROTO_DAMA_SLAVE:
1312 ax25->modulus = AX25_MODULUS;
1313 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1314 if (ax25->ax25_dev->dama.slave)
1315 ax25_ds_establish_data_link(ax25);
1317 ax25_std_establish_data_link(ax25);
1322 ax25->state = AX25_STATE_1;
1324 ax25_start_heartbeat(ax25);
1327 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1332 if (sk->sk_state == TCP_SYN_SENT) {
1336 prepare_to_wait(sk_sleep(sk), &wait,
1337 TASK_INTERRUPTIBLE);
1338 if (sk->sk_state != TCP_SYN_SENT)
1340 if (!signal_pending(current)) {
1349 finish_wait(sk_sleep(sk), &wait);
1355 if (sk->sk_state != TCP_ESTABLISHED) {
1356 /* Not in ABM, not in WAIT_UA -> failed */
1357 sock->state = SS_UNCONNECTED;
1358 err = sock_error(sk); /* Always set at this point */
1362 sock->state = SS_CONNECTED;
1371 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags,
1374 struct sk_buff *skb;
1380 if (sock->state != SS_UNCONNECTED)
1383 if ((sk = sock->sk) == NULL)
1387 if (sk->sk_type != SOCK_SEQPACKET) {
1392 if (sk->sk_state != TCP_LISTEN) {
1398 * The read queue this time is holding sockets ready to use
1399 * hooked into the SABM we saved
1402 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1403 skb = skb_dequeue(&sk->sk_receive_queue);
1407 if (flags & O_NONBLOCK) {
1411 if (!signal_pending(current)) {
1420 finish_wait(sk_sleep(sk), &wait);
1426 sock_graft(newsk, newsock);
1428 /* Now attach up the new socket */
1430 sk->sk_ack_backlog--;
1431 newsock->state = SS_CONNECTED;
1439 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1440 int *uaddr_len, int peer)
1442 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1443 struct sock *sk = sock->sk;
1444 unsigned char ndigi, i;
1448 memset(fsa, 0, sizeof(*fsa));
1450 ax25 = sk_to_ax25(sk);
1453 if (sk->sk_state != TCP_ESTABLISHED) {
1458 fsa->fsa_ax25.sax25_family = AF_AX25;
1459 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1461 if (ax25->digipeat != NULL) {
1462 ndigi = ax25->digipeat->ndigi;
1463 fsa->fsa_ax25.sax25_ndigis = ndigi;
1464 for (i = 0; i < ndigi; i++)
1465 fsa->fsa_digipeater[i] =
1466 ax25->digipeat->calls[i];
1469 fsa->fsa_ax25.sax25_family = AF_AX25;
1470 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1471 fsa->fsa_ax25.sax25_ndigis = 1;
1472 if (ax25->ax25_dev != NULL) {
1473 memcpy(&fsa->fsa_digipeater[0],
1474 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1476 fsa->fsa_digipeater[0] = null_ax25_address;
1479 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1487 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1489 DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1490 struct sock *sk = sock->sk;
1491 struct sockaddr_ax25 sax;
1492 struct sk_buff *skb;
1493 ax25_digi dtmp, *dp;
1496 int lv, err, addr_len = msg->msg_namelen;
1498 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1502 ax25 = sk_to_ax25(sk);
1504 if (sock_flag(sk, SOCK_ZAPPED)) {
1505 err = -EADDRNOTAVAIL;
1509 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1510 send_sig(SIGPIPE, current, 0);
1515 if (ax25->ax25_dev == NULL) {
1520 if (len > ax25->ax25_dev->dev->mtu) {
1526 if (usax->sax25_family != AF_AX25) {
1531 if (addr_len == sizeof(struct sockaddr_ax25))
1532 /* ax25_sendmsg(): uses obsolete socket structure */
1534 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1535 /* support for old structure may go away some time
1536 * ax25_sendmsg(): uses old (6 digipeater)
1539 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1540 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1546 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1548 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1550 /* Valid number of digipeaters ? */
1551 if (usax->sax25_ndigis < 1 ||
1552 usax->sax25_ndigis > AX25_MAX_DIGIS ||
1553 addr_len < sizeof(struct sockaddr_ax25) +
1554 sizeof(ax25_address) * usax->sax25_ndigis) {
1559 dtmp.ndigi = usax->sax25_ndigis;
1561 while (ct < usax->sax25_ndigis) {
1562 dtmp.repeated[ct] = 0;
1563 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1567 dtmp.lastrepeat = 0;
1571 if (sk->sk_type == SOCK_SEQPACKET &&
1572 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1576 if (usax->sax25_ndigis == 0)
1582 * FIXME: 1003.1g - if the socket is like this because
1583 * it has become closed (not started closed) and is VC
1584 * we ought to SIGPIPE, EPIPE
1586 if (sk->sk_state != TCP_ESTABLISHED) {
1590 sax.sax25_family = AF_AX25;
1591 sax.sax25_call = ax25->dest_addr;
1592 dp = ax25->digipeat;
1595 /* Build a packet */
1596 /* Assume the worst case */
1597 size = len + ax25->ax25_dev->dev->hard_header_len;
1599 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1603 skb_reserve(skb, size - len);
1605 /* User data follows immediately after the AX.25 data */
1606 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1612 skb_reset_network_header(skb);
1614 /* Add the PID if one is not supplied by the user in the skb */
1616 *(u8 *)skb_push(skb, 1) = sk->sk_protocol;
1618 if (sk->sk_type == SOCK_SEQPACKET) {
1619 /* Connected mode sockets go via the LAPB machine */
1620 if (sk->sk_state != TCP_ESTABLISHED) {
1626 /* Shove it onto the queue and kick */
1627 ax25_output(ax25, ax25->paclen, skb);
1633 skb_push(skb, 1 + ax25_addr_size(dp));
1635 /* Building AX.25 Header */
1637 /* Build an AX.25 header */
1638 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1639 dp, AX25_COMMAND, AX25_MODULUS);
1641 skb_set_transport_header(skb, lv);
1643 *skb_transport_header(skb) = AX25_UI;
1645 /* Datagram frames go straight out of the door as UI */
1646 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1656 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1659 struct sock *sk = sock->sk;
1660 struct sk_buff *skb;
1666 * This works for seqpacket too. The receiver has ordered the
1667 * queue for us! We do one quick check first though
1669 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1674 /* Now we can treat all alike */
1675 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1676 flags & MSG_DONTWAIT, &err);
1680 if (!sk_to_ax25(sk)->pidincl)
1681 skb_pull(skb, 1); /* Remove PID */
1683 skb_reset_transport_header(skb);
1686 if (copied > size) {
1688 msg->msg_flags |= MSG_TRUNC;
1691 skb_copy_datagram_msg(skb, 0, msg, copied);
1693 if (msg->msg_name) {
1696 const unsigned char *mac = skb_mac_header(skb);
1697 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1699 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1700 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1702 sax->sax25_family = AF_AX25;
1703 /* We set this correctly, even though we may not let the
1704 application know the digi calls further down (because it
1705 did NOT ask to know them). This could get political... **/
1706 sax->sax25_ndigis = digi.ndigi;
1707 sax->sax25_call = src;
1709 if (sax->sax25_ndigis != 0) {
1711 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1713 for (ct = 0; ct < digi.ndigi; ct++)
1714 fsa->fsa_digipeater[ct] = digi.calls[ct];
1716 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1719 skb_free_datagram(sk, skb);
1728 static int ax25_shutdown(struct socket *sk, int how)
1730 /* FIXME - generate DM and RNR states */
1734 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1736 struct sock *sk = sock->sk;
1737 void __user *argp = (void __user *)arg;
1745 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1748 res = put_user(amount, (int __user *)argp);
1753 struct sk_buff *skb;
1755 /* These two are safe on a single CPU system as only user tasks fiddle here */
1756 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1758 res = put_user(amount, (int __user *) argp);
1763 res = sock_get_timestamp(sk, argp);
1767 res = sock_get_timestampns(sk, argp);
1770 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1771 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1772 case SIOCAX25GETUID: {
1773 struct sockaddr_ax25 sax25;
1774 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1778 res = ax25_uid_ioctl(cmd, &sax25);
1782 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1784 if (!capable(CAP_NET_ADMIN)) {
1788 if (get_user(amount, (long __user *)argp)) {
1792 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1796 ax25_uid_policy = amount;
1804 if (!capable(CAP_NET_ADMIN)) {
1808 res = ax25_rt_ioctl(cmd, argp);
1811 case SIOCAX25CTLCON:
1812 if (!capable(CAP_NET_ADMIN)) {
1816 res = ax25_ctl_ioctl(cmd, argp);
1819 case SIOCAX25GETINFO:
1820 case SIOCAX25GETINFOOLD: {
1821 ax25_cb *ax25 = sk_to_ax25(sk);
1822 struct ax25_info_struct ax25_info;
1824 ax25_info.t1 = ax25->t1 / HZ;
1825 ax25_info.t2 = ax25->t2 / HZ;
1826 ax25_info.t3 = ax25->t3 / HZ;
1827 ax25_info.idle = ax25->idle / (60 * HZ);
1828 ax25_info.n2 = ax25->n2;
1829 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1830 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1831 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1832 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1833 ax25_info.n2count = ax25->n2count;
1834 ax25_info.state = ax25->state;
1835 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1836 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1837 ax25_info.vs = ax25->vs;
1838 ax25_info.vr = ax25->vr;
1839 ax25_info.va = ax25->va;
1840 ax25_info.vs_max = ax25->vs; /* reserved */
1841 ax25_info.paclen = ax25->paclen;
1842 ax25_info.window = ax25->window;
1844 /* old structure? */
1845 if (cmd == SIOCAX25GETINFOOLD) {
1846 static int warned = 0;
1848 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1853 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1858 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1867 case SIOCAX25ADDFWD:
1868 case SIOCAX25DELFWD: {
1869 struct ax25_fwd_struct ax25_fwd;
1870 if (!capable(CAP_NET_ADMIN)) {
1874 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1878 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1884 case SIOCGIFDSTADDR:
1885 case SIOCSIFDSTADDR:
1886 case SIOCGIFBRDADDR:
1887 case SIOCSIFBRDADDR:
1888 case SIOCGIFNETMASK:
1889 case SIOCSIFNETMASK:
1904 #ifdef CONFIG_PROC_FS
1906 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1907 __acquires(ax25_list_lock)
1909 spin_lock_bh(&ax25_list_lock);
1910 return seq_hlist_start(&ax25_list, *pos);
1913 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1915 return seq_hlist_next(v, &ax25_list, pos);
1918 static void ax25_info_stop(struct seq_file *seq, void *v)
1919 __releases(ax25_list_lock)
1921 spin_unlock_bh(&ax25_list_lock);
1924 static int ax25_info_show(struct seq_file *seq, void *v)
1926 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1933 * 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
1936 seq_printf(seq, "%8.8lx %s %s%s ",
1938 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1939 ax2asc(buf, &ax25->source_addr),
1940 ax25->iamdigi? "*":"");
1941 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1943 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1944 seq_printf(seq, ",%s%s",
1945 ax2asc(buf, &ax25->digipeat->calls[k]),
1946 ax25->digipeat->repeated[k]? "*":"");
1949 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1951 ax25->vs, ax25->vr, ax25->va,
1952 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1953 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1954 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1955 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1956 ax25->idle / (60 * HZ),
1957 ax25->n2count, ax25->n2,
1962 if (ax25->sk != NULL) {
1963 seq_printf(seq, " %d %d %lu\n",
1964 sk_wmem_alloc_get(ax25->sk),
1965 sk_rmem_alloc_get(ax25->sk),
1966 sock_i_ino(ax25->sk));
1968 seq_puts(seq, " * * *\n");
1973 static const struct seq_operations ax25_info_seqops = {
1974 .start = ax25_info_start,
1975 .next = ax25_info_next,
1976 .stop = ax25_info_stop,
1977 .show = ax25_info_show,
1980 static int ax25_info_open(struct inode *inode, struct file *file)
1982 return seq_open(file, &ax25_info_seqops);
1985 static const struct file_operations ax25_info_fops = {
1986 .owner = THIS_MODULE,
1987 .open = ax25_info_open,
1989 .llseek = seq_lseek,
1990 .release = seq_release,
1995 static const struct net_proto_family ax25_family_ops = {
1997 .create = ax25_create,
1998 .owner = THIS_MODULE,
2001 static const struct proto_ops ax25_proto_ops = {
2003 .owner = THIS_MODULE,
2004 .release = ax25_release,
2006 .connect = ax25_connect,
2007 .socketpair = sock_no_socketpair,
2008 .accept = ax25_accept,
2009 .getname = ax25_getname,
2010 .poll = datagram_poll,
2011 .ioctl = ax25_ioctl,
2012 .listen = ax25_listen,
2013 .shutdown = ax25_shutdown,
2014 .setsockopt = ax25_setsockopt,
2015 .getsockopt = ax25_getsockopt,
2016 .sendmsg = ax25_sendmsg,
2017 .recvmsg = ax25_recvmsg,
2018 .mmap = sock_no_mmap,
2019 .sendpage = sock_no_sendpage,
2023 * Called by socket.c on kernel start up
2025 static struct packet_type ax25_packet_type __read_mostly = {
2026 .type = cpu_to_be16(ETH_P_AX25),
2027 .func = ax25_kiss_rcv,
2030 static struct notifier_block ax25_dev_notifier = {
2031 .notifier_call = ax25_device_event,
2034 static int __init ax25_init(void)
2036 int rc = proto_register(&ax25_proto, 0);
2041 sock_register(&ax25_family_ops);
2042 dev_add_pack(&ax25_packet_type);
2043 register_netdevice_notifier(&ax25_dev_notifier);
2045 proc_create("ax25_route", S_IRUGO, init_net.proc_net,
2047 proc_create("ax25", S_IRUGO, init_net.proc_net, &ax25_info_fops);
2048 proc_create("ax25_calls", S_IRUGO, init_net.proc_net, &ax25_uid_fops);
2052 module_init(ax25_init);
2055 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2056 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2057 MODULE_LICENSE("GPL");
2058 MODULE_ALIAS_NETPROTO(PF_AX25);
2060 static void __exit ax25_exit(void)
2062 remove_proc_entry("ax25_route", init_net.proc_net);
2063 remove_proc_entry("ax25", init_net.proc_net);
2064 remove_proc_entry("ax25_calls", init_net.proc_net);
2066 unregister_netdevice_notifier(&ax25_dev_notifier);
2068 dev_remove_pack(&ax25_packet_type);
2070 sock_unregister(PF_AX25);
2071 proto_unregister(&ax25_proto);
2077 module_exit(ax25_exit);