2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
7 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
8 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
10 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
11 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
12 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
13 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
14 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
16 #include <linux/capability.h>
17 #include <linux/module.h>
18 #include <linux/errno.h>
19 #include <linux/types.h>
20 #include <linux/socket.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/smp_lock.h>
27 #include <linux/sockios.h>
28 #include <linux/net.h>
30 #include <linux/inet.h>
31 #include <linux/netdevice.h>
32 #include <linux/if_arp.h>
33 #include <linux/skbuff.h>
35 #include <asm/uaccess.h>
36 #include <asm/system.h>
37 #include <linux/fcntl.h>
38 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
40 #include <linux/interrupt.h>
41 #include <linux/notifier.h>
42 #include <linux/proc_fs.h>
43 #include <linux/stat.h>
44 #include <linux/netfilter.h>
45 #include <linux/sysctl.h>
46 #include <linux/init.h>
47 #include <linux/spinlock.h>
48 #include <net/tcp_states.h>
54 HLIST_HEAD(ax25_list);
55 DEFINE_SPINLOCK(ax25_list_lock);
57 static const struct proto_ops ax25_proto_ops;
59 static void ax25_free_sock(struct sock *sk)
61 ax25_cb_put(ax25_sk(sk));
65 * Socket removal during an interrupt is now safe.
67 static void ax25_cb_del(ax25_cb *ax25)
69 if (!hlist_unhashed(&ax25->ax25_node)) {
70 spin_lock_bh(&ax25_list_lock);
71 hlist_del_init(&ax25->ax25_node);
72 spin_unlock_bh(&ax25_list_lock);
78 * Kill all bound sockets on a dropped device.
80 static void ax25_kill_by_device(struct net_device *dev)
84 struct hlist_node *node;
86 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
89 spin_lock_bh(&ax25_list_lock);
90 ax25_for_each(s, node, &ax25_list) {
91 if (s->ax25_dev == ax25_dev) {
93 ax25_disconnect(s, ENETUNREACH);
96 spin_unlock_bh(&ax25_list_lock);
100 * Handle device status changes.
102 static int ax25_device_event(struct notifier_block *this, unsigned long event,
105 struct net_device *dev = (struct net_device *)ptr;
107 /* Reject non AX.25 devices */
108 if (dev->type != ARPHRD_AX25)
113 ax25_dev_device_up(dev);
116 ax25_kill_by_device(dev);
117 ax25_rt_device_down(dev);
118 ax25_dev_device_down(dev);
128 * Add a socket to the bound sockets list.
130 void ax25_cb_add(ax25_cb *ax25)
132 spin_lock_bh(&ax25_list_lock);
134 hlist_add_head(&ax25->ax25_node, &ax25_list);
135 spin_unlock_bh(&ax25_list_lock);
139 * Find a socket that wants to accept the SABM we have just
142 struct sock *ax25_find_listener(ax25_address *addr, int digi,
143 struct net_device *dev, int type)
146 struct hlist_node *node;
148 spin_lock_bh(&ax25_list_lock);
149 ax25_for_each(s, node, &ax25_list) {
150 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
152 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
153 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
154 /* If device is null we match any device */
155 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
157 spin_unlock_bh(&ax25_list_lock);
162 spin_unlock_bh(&ax25_list_lock);
168 * Find an AX.25 socket given both ends.
170 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
173 struct sock *sk = NULL;
175 struct hlist_node *node;
177 spin_lock_bh(&ax25_list_lock);
178 ax25_for_each(s, node, &ax25_list) {
179 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
180 !ax25cmp(&s->dest_addr, dest_addr) &&
181 s->sk->sk_type == type) {
188 spin_unlock_bh(&ax25_list_lock);
194 * Find an AX.25 control block given both ends. It will only pick up
195 * floating AX.25 control blocks or non Raw socket bound control blocks.
197 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
198 ax25_digi *digi, struct net_device *dev)
201 struct hlist_node *node;
203 spin_lock_bh(&ax25_list_lock);
204 ax25_for_each(s, node, &ax25_list) {
205 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
207 if (s->ax25_dev == NULL)
209 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
210 if (digi != NULL && digi->ndigi != 0) {
211 if (s->digipeat == NULL)
213 if (ax25digicmp(s->digipeat, digi) != 0)
216 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
220 spin_unlock_bh(&ax25_list_lock);
225 spin_unlock_bh(&ax25_list_lock);
230 EXPORT_SYMBOL(ax25_find_cb);
232 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
235 struct sk_buff *copy;
236 struct hlist_node *node;
238 spin_lock_bh(&ax25_list_lock);
239 ax25_for_each(s, node, &ax25_list) {
240 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
241 s->sk->sk_type == SOCK_RAW &&
242 s->sk->sk_protocol == proto &&
243 s->ax25_dev->dev == skb->dev &&
244 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
245 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
247 if (sock_queue_rcv_skb(s->sk, copy) != 0)
251 spin_unlock_bh(&ax25_list_lock);
257 void ax25_destroy_socket(ax25_cb *);
260 * Handler for deferred kills.
262 static void ax25_destroy_timer(unsigned long data)
264 ax25_cb *ax25=(ax25_cb *)data;
271 ax25_destroy_socket(ax25);
277 * This is called from user mode and the timers. Thus it protects itself
278 * against interrupt users but doesn't worry about being called during
279 * work. Once it is removed from the queue no interrupt or bottom half
280 * will touch it and we are (fairly 8-) ) safe.
282 void ax25_destroy_socket(ax25_cb *ax25)
288 ax25_stop_heartbeat(ax25);
289 ax25_stop_t1timer(ax25);
290 ax25_stop_t2timer(ax25);
291 ax25_stop_t3timer(ax25);
292 ax25_stop_idletimer(ax25);
294 ax25_clear_queues(ax25); /* Flush the queues */
296 if (ax25->sk != NULL) {
297 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
298 if (skb->sk != ax25->sk) {
299 /* A pending connection */
300 ax25_cb *sax25 = ax25_sk(skb->sk);
302 /* Queue the unaccepted socket for death */
303 sock_orphan(skb->sk);
305 ax25_start_heartbeat(sax25);
306 sax25->state = AX25_STATE_0;
311 skb_queue_purge(&ax25->sk->sk_write_queue);
314 if (ax25->sk != NULL) {
315 if (atomic_read(&ax25->sk->sk_wmem_alloc) ||
316 atomic_read(&ax25->sk->sk_rmem_alloc)) {
317 /* Defer: outstanding buffers */
318 init_timer(&ax25->dtimer);
319 ax25->dtimer.expires = jiffies + 2 * HZ;
320 ax25->dtimer.function = ax25_destroy_timer;
321 ax25->dtimer.data = (unsigned long)ax25;
322 add_timer(&ax25->dtimer);
324 struct sock *sk=ax25->sk;
334 * dl1bke 960311: set parameters for existing AX.25 connections,
335 * includes a KILL command to abort any connection.
336 * VERY useful for debugging ;-)
338 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
340 struct ax25_ctl_struct ax25_ctl;
346 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
349 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
352 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
355 digi.ndigi = ax25_ctl.digi_count;
356 for (k = 0; k < digi.ndigi; k++)
357 digi.calls[k] = ax25_ctl.digi_addr[k];
359 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
362 switch (ax25_ctl.cmd) {
364 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
365 #ifdef CONFIG_AX25_DAMA_SLAVE
366 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
369 ax25_disconnect(ax25, ENETRESET);
373 if (ax25->modulus == AX25_MODULUS) {
374 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
377 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
380 ax25->window = ax25_ctl.arg;
384 if (ax25_ctl.arg < 1)
386 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
387 ax25->t1 = ax25_ctl.arg * HZ;
391 if (ax25_ctl.arg < 1)
393 ax25->t2 = ax25_ctl.arg * HZ;
397 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
400 ax25->n2 = ax25_ctl.arg;
404 if (ax25_ctl.arg < 0)
406 ax25->t3 = ax25_ctl.arg * HZ;
410 if (ax25_ctl.arg < 0)
412 ax25->idle = ax25_ctl.arg * 60 * HZ;
416 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
418 ax25->paclen = ax25_ctl.arg;
428 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
430 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
431 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
432 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
433 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
434 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
435 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
436 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
437 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
439 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
440 ax25->modulus = AX25_EMODULUS;
441 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
443 ax25->modulus = AX25_MODULUS;
444 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
449 * Fill in a created AX.25 created control block with the default
450 * values for a particular device.
452 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
454 ax25->ax25_dev = ax25_dev;
456 if (ax25->ax25_dev != NULL) {
457 ax25_fillin_cb_from_dev(ax25, ax25_dev);
462 * No device, use kernel / AX.25 spec default values
464 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
465 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
466 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
467 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
468 ax25->n2 = AX25_DEF_N2;
469 ax25->paclen = AX25_DEF_PACLEN;
470 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
471 ax25->backoff = AX25_DEF_BACKOFF;
473 if (AX25_DEF_AXDEFMODE) {
474 ax25->modulus = AX25_EMODULUS;
475 ax25->window = AX25_DEF_EWINDOW;
477 ax25->modulus = AX25_MODULUS;
478 ax25->window = AX25_DEF_WINDOW;
483 * Create an empty AX.25 control block.
485 ax25_cb *ax25_create_cb(void)
489 if ((ax25 = kmalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
492 memset(ax25, 0x00, sizeof(*ax25));
493 atomic_set(&ax25->refcount, 1);
495 skb_queue_head_init(&ax25->write_queue);
496 skb_queue_head_init(&ax25->frag_queue);
497 skb_queue_head_init(&ax25->ack_queue);
498 skb_queue_head_init(&ax25->reseq_queue);
500 init_timer(&ax25->timer);
501 init_timer(&ax25->t1timer);
502 init_timer(&ax25->t2timer);
503 init_timer(&ax25->t3timer);
504 init_timer(&ax25->idletimer);
506 ax25_fillin_cb(ax25, NULL);
508 ax25->state = AX25_STATE_0;
514 * Handling for system calls applied via the various interfaces to an
518 static int ax25_setsockopt(struct socket *sock, int level, int optname,
519 char __user *optval, int optlen)
521 struct sock *sk = sock->sk;
523 struct net_device *dev;
524 char devname[IFNAMSIZ];
527 if (level != SOL_AX25)
530 if (optlen < sizeof(int))
533 if (get_user(opt, (int __user *)optval))
541 if (ax25->modulus == AX25_MODULUS) {
542 if (opt < 1 || opt > 7) {
547 if (opt < 1 || opt > 63) {
560 ax25->rtt = (opt * HZ) / 2;
573 if (opt < 1 || opt > 31) {
593 ax25->idle = opt * 60 * HZ;
597 if (opt < 0 || opt > 2) {
605 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
609 ax25->pidincl = opt ? 1 : 0;
613 ax25->iamdigi = opt ? 1 : 0;
617 if (opt < 16 || opt > 65535) {
624 case SO_BINDTODEVICE:
625 if (optlen > IFNAMSIZ)
627 if (copy_from_user(devname, optval, optlen)) {
632 dev = dev_get_by_name(devname);
638 if (sk->sk_type == SOCK_SEQPACKET &&
639 (sock->state != SS_UNCONNECTED ||
640 sk->sk_state == TCP_LISTEN)) {
641 res = -EADDRNOTAVAIL;
646 ax25->ax25_dev = ax25_dev_ax25dev(dev);
647 ax25_fillin_cb(ax25, ax25->ax25_dev);
658 static int ax25_getsockopt(struct socket *sock, int level, int optname,
659 char __user *optval, int __user *optlen)
661 struct sock *sk = sock->sk;
663 struct ax25_dev *ax25_dev;
664 char devname[IFNAMSIZ];
669 if (level != SOL_AX25)
672 if (get_user(maxlen, optlen))
678 valptr = (void *) &val;
679 length = min_t(unsigned int, maxlen, sizeof(int));
706 val = ax25->idle / (60 * HZ);
714 val = (ax25->modulus == AX25_EMODULUS);
729 case SO_BINDTODEVICE:
730 ax25_dev = ax25->ax25_dev;
732 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
733 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
734 length = strlen(devname) + 1;
740 valptr = (void *) devname;
749 if (put_user(length, optlen))
752 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
755 static int ax25_listen(struct socket *sock, int backlog)
757 struct sock *sk = sock->sk;
761 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
762 sk->sk_max_ack_backlog = backlog;
763 sk->sk_state = TCP_LISTEN;
775 * XXX: when creating ax25_sock we should update the .obj_size setting
778 static struct proto ax25_proto = {
780 .owner = THIS_MODULE,
781 .obj_size = sizeof(struct sock),
784 static int ax25_create(struct socket *sock, int protocol)
789 switch (sock->type) {
791 if (protocol == 0 || protocol == PF_AX25)
792 protocol = AX25_P_TEXT;
798 case PF_AX25: /* For CLX */
799 protocol = AX25_P_TEXT;
812 return -ESOCKTNOSUPPORT;
813 #ifdef CONFIG_NETROM_MODULE
815 if (ax25_protocol_is_registered(AX25_P_NETROM))
816 return -ESOCKTNOSUPPORT;
818 #ifdef CONFIG_ROSE_MODULE
820 if (ax25_protocol_is_registered(AX25_P_ROSE))
821 return -ESOCKTNOSUPPORT;
831 return -ESOCKTNOSUPPORT;
834 if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, &ax25_proto, 1)) == NULL)
837 ax25 = sk->sk_protinfo = ax25_create_cb();
843 sock_init_data(sock, sk);
845 sk->sk_destruct = ax25_free_sock;
846 sock->ops = &ax25_proto_ops;
847 sk->sk_protocol = protocol;
854 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
857 ax25_cb *ax25, *oax25;
859 if ((sk = sk_alloc(PF_AX25, GFP_ATOMIC, osk->sk_prot, 1)) == NULL)
862 if ((ax25 = ax25_create_cb()) == NULL) {
867 switch (osk->sk_type) {
878 sock_init_data(NULL, sk);
880 sk->sk_destruct = ax25_free_sock;
881 sk->sk_type = osk->sk_type;
882 sk->sk_socket = osk->sk_socket;
883 sk->sk_priority = osk->sk_priority;
884 sk->sk_protocol = osk->sk_protocol;
885 sk->sk_rcvbuf = osk->sk_rcvbuf;
886 sk->sk_sndbuf = osk->sk_sndbuf;
887 sk->sk_state = TCP_ESTABLISHED;
888 sk->sk_sleep = osk->sk_sleep;
889 sock_copy_flags(sk, osk);
891 oax25 = ax25_sk(osk);
893 ax25->modulus = oax25->modulus;
894 ax25->backoff = oax25->backoff;
895 ax25->pidincl = oax25->pidincl;
896 ax25->iamdigi = oax25->iamdigi;
897 ax25->rtt = oax25->rtt;
898 ax25->t1 = oax25->t1;
899 ax25->t2 = oax25->t2;
900 ax25->t3 = oax25->t3;
901 ax25->n2 = oax25->n2;
902 ax25->idle = oax25->idle;
903 ax25->paclen = oax25->paclen;
904 ax25->window = oax25->window;
906 ax25->ax25_dev = ax25_dev;
907 ax25->source_addr = oax25->source_addr;
909 if (oax25->digipeat != NULL) {
910 if ((ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
916 memcpy(ax25->digipeat, oax25->digipeat, sizeof(ax25_digi));
919 sk->sk_protinfo = ax25;
925 static int ax25_release(struct socket *sock)
927 struct sock *sk = sock->sk;
938 if (sk->sk_type == SOCK_SEQPACKET) {
939 switch (ax25->state) {
942 ax25_disconnect(ax25, 0);
944 ax25_destroy_socket(ax25);
949 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
951 ax25_disconnect(ax25, 0);
953 ax25_destroy_socket(ax25);
958 ax25_clear_queues(ax25);
961 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
962 case AX25_PROTO_STD_SIMPLEX:
963 case AX25_PROTO_STD_DUPLEX:
964 ax25_send_control(ax25,
968 ax25_stop_t2timer(ax25);
969 ax25_stop_t3timer(ax25);
970 ax25_stop_idletimer(ax25);
972 #ifdef CONFIG_AX25_DAMA_SLAVE
973 case AX25_PROTO_DAMA_SLAVE:
974 ax25_stop_t3timer(ax25);
975 ax25_stop_idletimer(ax25);
979 ax25_calculate_t1(ax25);
980 ax25_start_t1timer(ax25);
981 ax25->state = AX25_STATE_2;
982 sk->sk_state = TCP_CLOSE;
983 sk->sk_shutdown |= SEND_SHUTDOWN;
984 sk->sk_state_change(sk);
985 sock_set_flag(sk, SOCK_DESTROY);
992 sk->sk_state = TCP_CLOSE;
993 sk->sk_shutdown |= SEND_SHUTDOWN;
994 sk->sk_state_change(sk);
995 ax25_destroy_socket(ax25);
1006 * We support a funny extension here so you can (as root) give any callsign
1007 * digipeated via a local address as source. This hack is obsolete now
1008 * that we've implemented support for SO_BINDTODEVICE. It is however small
1009 * and trivially backward compatible.
1011 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1013 struct sock *sk = sock->sk;
1014 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1015 ax25_dev *ax25_dev = NULL;
1016 ax25_uid_assoc *user;
1021 if (addr_len != sizeof(struct sockaddr_ax25) &&
1022 addr_len != sizeof(struct full_sockaddr_ax25)) {
1023 /* support for old structure may go away some time */
1024 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1025 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1029 printk(KERN_WARNING "ax25_bind(): %s uses old (6 digipeater) socket structure.\n",
1033 if (addr->fsa_ax25.sax25_family != AF_AX25)
1036 user = ax25_findbyuid(current->euid);
1041 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1044 call = addr->fsa_ax25.sax25_call;
1050 if (!sock_flag(sk, SOCK_ZAPPED)) {
1055 ax25->source_addr = call;
1058 * User already set interface with SO_BINDTODEVICE
1060 if (ax25->ax25_dev != NULL)
1063 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1064 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1065 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1066 err = -EADDRNOTAVAIL;
1070 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1071 err = -EADDRNOTAVAIL;
1076 if (ax25_dev != NULL)
1077 ax25_fillin_cb(ax25, ax25_dev);
1081 sock_reset_flag(sk, SOCK_ZAPPED);
1090 * FIXME: nonblock behaviour looks like it may have a bug.
1092 static int ax25_connect(struct socket *sock, struct sockaddr *uaddr,
1093 int addr_len, int flags)
1095 struct sock *sk = sock->sk;
1096 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1097 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1098 ax25_digi *digi = NULL;
1099 int ct = 0, err = 0;
1102 * some sanity checks. code further down depends on this
1105 if (addr_len == sizeof(struct sockaddr_ax25)) {
1106 /* support for this will go away in early 2.5.x */
1107 printk(KERN_WARNING "ax25_connect(): %s uses obsolete socket structure\n",
1110 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1111 /* support for old structure may go away some time */
1112 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1113 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1117 printk(KERN_WARNING "ax25_connect(): %s uses old (6 digipeater) socket structure.\n",
1121 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1126 /* deal with restarts */
1127 if (sock->state == SS_CONNECTING) {
1128 switch (sk->sk_state) {
1129 case TCP_SYN_SENT: /* still trying */
1133 case TCP_ESTABLISHED: /* connection established */
1134 sock->state = SS_CONNECTED;
1137 case TCP_CLOSE: /* connection refused */
1138 sock->state = SS_UNCONNECTED;
1139 err = -ECONNREFUSED;
1144 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1145 err = -EISCONN; /* No reconnect on a seqpacket socket */
1149 sk->sk_state = TCP_CLOSE;
1150 sock->state = SS_UNCONNECTED;
1152 kfree(ax25->digipeat);
1153 ax25->digipeat = NULL;
1156 * Handle digi-peaters to be used.
1158 if (addr_len > sizeof(struct sockaddr_ax25) &&
1159 fsa->fsa_ax25.sax25_ndigis != 0) {
1160 /* Valid number of digipeaters ? */
1161 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1166 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1171 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1172 digi->lastrepeat = -1;
1174 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1175 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1176 AX25_HBIT) && ax25->iamdigi) {
1177 digi->repeated[ct] = 1;
1178 digi->lastrepeat = ct;
1180 digi->repeated[ct] = 0;
1182 digi->calls[ct] = fsa->fsa_digipeater[ct];
1188 * Must bind first - autobinding in this may or may not work. If
1189 * the socket is already bound, check to see if the device has
1190 * been filled in, error if it hasn't.
1192 if (sock_flag(sk, SOCK_ZAPPED)) {
1193 /* check if we can remove this feature. It is broken. */
1194 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1196 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1201 ax25_fillin_cb(ax25, ax25->ax25_dev);
1204 if (ax25->ax25_dev == NULL) {
1206 err = -EHOSTUNREACH;
1211 if (sk->sk_type == SOCK_SEQPACKET &&
1212 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1213 ax25->ax25_dev->dev))) {
1215 err = -EADDRINUSE; /* Already such a connection */
1220 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1221 ax25->digipeat = digi;
1223 /* First the easy one */
1224 if (sk->sk_type != SOCK_SEQPACKET) {
1225 sock->state = SS_CONNECTED;
1226 sk->sk_state = TCP_ESTABLISHED;
1230 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1231 sock->state = SS_CONNECTING;
1232 sk->sk_state = TCP_SYN_SENT;
1234 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1235 case AX25_PROTO_STD_SIMPLEX:
1236 case AX25_PROTO_STD_DUPLEX:
1237 ax25_std_establish_data_link(ax25);
1240 #ifdef CONFIG_AX25_DAMA_SLAVE
1241 case AX25_PROTO_DAMA_SLAVE:
1242 ax25->modulus = AX25_MODULUS;
1243 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1244 if (ax25->ax25_dev->dama.slave)
1245 ax25_ds_establish_data_link(ax25);
1247 ax25_std_establish_data_link(ax25);
1252 ax25->state = AX25_STATE_1;
1254 ax25_start_heartbeat(ax25);
1257 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1262 if (sk->sk_state == TCP_SYN_SENT) {
1263 struct task_struct *tsk = current;
1264 DECLARE_WAITQUEUE(wait, tsk);
1266 add_wait_queue(sk->sk_sleep, &wait);
1268 if (sk->sk_state != TCP_SYN_SENT)
1270 set_current_state(TASK_INTERRUPTIBLE);
1272 if (!signal_pending(tsk)) {
1277 current->state = TASK_RUNNING;
1278 remove_wait_queue(sk->sk_sleep, &wait);
1279 return -ERESTARTSYS;
1281 current->state = TASK_RUNNING;
1282 remove_wait_queue(sk->sk_sleep, &wait);
1285 if (sk->sk_state != TCP_ESTABLISHED) {
1286 /* Not in ABM, not in WAIT_UA -> failed */
1287 sock->state = SS_UNCONNECTED;
1288 err = sock_error(sk); /* Always set at this point */
1292 sock->state = SS_CONNECTED;
1302 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1304 struct task_struct *tsk = current;
1305 DECLARE_WAITQUEUE(wait, tsk);
1306 struct sk_buff *skb;
1311 if (sock->state != SS_UNCONNECTED)
1314 if ((sk = sock->sk) == NULL)
1318 if (sk->sk_type != SOCK_SEQPACKET) {
1323 if (sk->sk_state != TCP_LISTEN) {
1329 * The read queue this time is holding sockets ready to use
1330 * hooked into the SABM we saved
1332 add_wait_queue(sk->sk_sleep, &wait);
1334 skb = skb_dequeue(&sk->sk_receive_queue);
1339 current->state = TASK_INTERRUPTIBLE;
1340 if (flags & O_NONBLOCK) {
1341 current->state = TASK_RUNNING;
1342 remove_wait_queue(sk->sk_sleep, &wait);
1343 return -EWOULDBLOCK;
1345 if (!signal_pending(tsk)) {
1350 current->state = TASK_RUNNING;
1351 remove_wait_queue(sk->sk_sleep, &wait);
1352 return -ERESTARTSYS;
1354 current->state = TASK_RUNNING;
1355 remove_wait_queue(sk->sk_sleep, &wait);
1358 newsk->sk_socket = newsock;
1359 newsk->sk_sleep = &newsock->wait;
1361 /* Now attach up the new socket */
1363 sk->sk_ack_backlog--;
1364 newsock->sk = newsk;
1365 newsock->state = SS_CONNECTED;
1373 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1374 int *uaddr_len, int peer)
1376 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1377 struct sock *sk = sock->sk;
1378 unsigned char ndigi, i;
1386 if (sk->sk_state != TCP_ESTABLISHED) {
1391 fsa->fsa_ax25.sax25_family = AF_AX25;
1392 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1393 fsa->fsa_ax25.sax25_ndigis = 0;
1395 if (ax25->digipeat != NULL) {
1396 ndigi = ax25->digipeat->ndigi;
1397 fsa->fsa_ax25.sax25_ndigis = ndigi;
1398 for (i = 0; i < ndigi; i++)
1399 fsa->fsa_digipeater[i] =
1400 ax25->digipeat->calls[i];
1403 fsa->fsa_ax25.sax25_family = AF_AX25;
1404 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1405 fsa->fsa_ax25.sax25_ndigis = 1;
1406 if (ax25->ax25_dev != NULL) {
1407 memcpy(&fsa->fsa_digipeater[0],
1408 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1410 fsa->fsa_digipeater[0] = null_ax25_address;
1413 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1421 static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1422 struct msghdr *msg, size_t len)
1424 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1425 struct sock *sk = sock->sk;
1426 struct sockaddr_ax25 sax;
1427 struct sk_buff *skb;
1428 ax25_digi dtmp, *dp;
1429 unsigned char *asmptr;
1432 int lv, err, addr_len = msg->msg_namelen;
1434 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1440 if (sock_flag(sk, SOCK_ZAPPED)) {
1441 err = -EADDRNOTAVAIL;
1445 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1446 send_sig(SIGPIPE, current, 0);
1451 if (ax25->ax25_dev == NULL) {
1456 if (len > ax25->ax25_dev->dev->mtu) {
1462 if (usax->sax25_family != AF_AX25) {
1467 if (addr_len == sizeof(struct sockaddr_ax25)) {
1468 printk(KERN_WARNING "ax25_sendmsg(): %s uses obsolete socket structure\n",
1471 else if (addr_len != sizeof(struct full_sockaddr_ax25)) {
1472 /* support for old structure may go away some time */
1473 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1474 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1479 printk(KERN_WARNING "ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n",
1483 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1485 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1487 /* Valid number of digipeaters ? */
1488 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1493 dtmp.ndigi = usax->sax25_ndigis;
1495 while (ct < usax->sax25_ndigis) {
1496 dtmp.repeated[ct] = 0;
1497 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1501 dtmp.lastrepeat = 0;
1505 if (sk->sk_type == SOCK_SEQPACKET &&
1506 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1510 if (usax->sax25_ndigis == 0)
1516 * FIXME: 1003.1g - if the socket is like this because
1517 * it has become closed (not started closed) and is VC
1518 * we ought to SIGPIPE, EPIPE
1520 if (sk->sk_state != TCP_ESTABLISHED) {
1524 sax.sax25_family = AF_AX25;
1525 sax.sax25_call = ax25->dest_addr;
1526 dp = ax25->digipeat;
1529 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built.\n");
1531 /* Build a packet */
1532 SOCK_DEBUG(sk, "AX.25: sendto: building packet.\n");
1534 /* Assume the worst case */
1535 size = len + ax25->ax25_dev->dev->hard_header_len;
1537 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1541 skb_reserve(skb, size - len);
1543 SOCK_DEBUG(sk, "AX.25: Appending user data\n");
1545 /* User data follows immediately after the AX.25 data */
1546 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1552 skb->nh.raw = skb->data;
1554 /* Add the PID if one is not supplied by the user in the skb */
1555 if (!ax25->pidincl) {
1556 asmptr = skb_push(skb, 1);
1557 *asmptr = sk->sk_protocol;
1560 SOCK_DEBUG(sk, "AX.25: Transmitting buffer\n");
1562 if (sk->sk_type == SOCK_SEQPACKET) {
1563 /* Connected mode sockets go via the LAPB machine */
1564 if (sk->sk_state != TCP_ESTABLISHED) {
1570 /* Shove it onto the queue and kick */
1571 ax25_output(ax25, ax25->paclen, skb);
1577 asmptr = skb_push(skb, 1 + ax25_addr_size(dp));
1579 SOCK_DEBUG(sk, "Building AX.25 Header (dp=%p).\n", dp);
1582 SOCK_DEBUG(sk, "Num digipeaters=%d\n", dp->ndigi);
1584 /* Build an AX.25 header */
1585 asmptr += (lv = ax25_addr_build(asmptr, &ax25->source_addr,
1586 &sax.sax25_call, dp,
1587 AX25_COMMAND, AX25_MODULUS));
1589 SOCK_DEBUG(sk, "Built header (%d bytes)\n",lv);
1591 skb->h.raw = asmptr;
1593 SOCK_DEBUG(sk, "base=%p pos=%p\n", skb->data, asmptr);
1597 /* Datagram frames go straight out of the door as UI */
1598 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1608 static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1609 struct msghdr *msg, size_t size, int flags)
1611 struct sock *sk = sock->sk;
1612 struct sk_buff *skb;
1618 * This works for seqpacket too. The receiver has ordered the
1619 * queue for us! We do one quick check first though
1621 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1626 /* Now we can treat all alike */
1627 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1628 flags & MSG_DONTWAIT, &err);
1632 if (!ax25_sk(sk)->pidincl)
1633 skb_pull(skb, 1); /* Remove PID */
1635 skb->h.raw = skb->data;
1638 if (copied > size) {
1640 msg->msg_flags |= MSG_TRUNC;
1643 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1645 if (msg->msg_namelen != 0) {
1646 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1650 ax25_addr_parse(skb->mac.raw+1, skb->data-skb->mac.raw-1, &src, NULL, &digi, NULL, NULL);
1652 sax->sax25_family = AF_AX25;
1653 /* We set this correctly, even though we may not let the
1654 application know the digi calls further down (because it
1655 did NOT ask to know them). This could get political... **/
1656 sax->sax25_ndigis = digi.ndigi;
1657 sax->sax25_call = src;
1659 if (sax->sax25_ndigis != 0) {
1661 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1663 for (ct = 0; ct < digi.ndigi; ct++)
1664 fsa->fsa_digipeater[ct] = digi.calls[ct];
1666 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1669 skb_free_datagram(sk, skb);
1678 static int ax25_shutdown(struct socket *sk, int how)
1680 /* FIXME - generate DM and RNR states */
1684 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1686 struct sock *sk = sock->sk;
1687 void __user *argp = (void __user *)arg;
1694 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1697 res = put_user(amount, (int __user *)argp);
1702 struct sk_buff *skb;
1704 /* These two are safe on a single CPU system as only user tasks fiddle here */
1705 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1707 res = put_user(amount, (int __user *) argp);
1712 res = sock_get_timestamp(sk, argp);
1715 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1716 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1717 case SIOCAX25GETUID: {
1718 struct sockaddr_ax25 sax25;
1719 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1723 res = ax25_uid_ioctl(cmd, &sax25);
1727 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1729 if (!capable(CAP_NET_ADMIN)) {
1733 if (get_user(amount, (long __user *)argp)) {
1737 if (amount > AX25_NOUID_BLOCK) {
1741 ax25_uid_policy = amount;
1749 if (!capable(CAP_NET_ADMIN)) {
1753 res = ax25_rt_ioctl(cmd, argp);
1756 case SIOCAX25CTLCON:
1757 if (!capable(CAP_NET_ADMIN)) {
1761 res = ax25_ctl_ioctl(cmd, argp);
1764 case SIOCAX25GETINFO:
1765 case SIOCAX25GETINFOOLD: {
1766 ax25_cb *ax25 = ax25_sk(sk);
1767 struct ax25_info_struct ax25_info;
1769 ax25_info.t1 = ax25->t1 / HZ;
1770 ax25_info.t2 = ax25->t2 / HZ;
1771 ax25_info.t3 = ax25->t3 / HZ;
1772 ax25_info.idle = ax25->idle / (60 * HZ);
1773 ax25_info.n2 = ax25->n2;
1774 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1775 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1776 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1777 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1778 ax25_info.n2count = ax25->n2count;
1779 ax25_info.state = ax25->state;
1780 ax25_info.rcv_q = atomic_read(&sk->sk_rmem_alloc);
1781 ax25_info.snd_q = atomic_read(&sk->sk_wmem_alloc);
1782 ax25_info.vs = ax25->vs;
1783 ax25_info.vr = ax25->vr;
1784 ax25_info.va = ax25->va;
1785 ax25_info.vs_max = ax25->vs; /* reserved */
1786 ax25_info.paclen = ax25->paclen;
1787 ax25_info.window = ax25->window;
1789 /* old structure? */
1790 if (cmd == SIOCAX25GETINFOOLD) {
1791 static int warned = 0;
1793 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1798 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1803 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1812 case SIOCAX25ADDFWD:
1813 case SIOCAX25DELFWD: {
1814 struct ax25_fwd_struct ax25_fwd;
1815 if (!capable(CAP_NET_ADMIN)) {
1819 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1823 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1829 case SIOCGIFDSTADDR:
1830 case SIOCSIFDSTADDR:
1831 case SIOCGIFBRDADDR:
1832 case SIOCSIFBRDADDR:
1833 case SIOCGIFNETMASK:
1834 case SIOCSIFNETMASK:
1849 #ifdef CONFIG_PROC_FS
1851 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1853 struct ax25_cb *ax25;
1854 struct hlist_node *node;
1857 spin_lock_bh(&ax25_list_lock);
1858 ax25_for_each(ax25, node, &ax25_list) {
1866 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1870 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1871 struct ax25_cb, ax25_node);
1874 static void ax25_info_stop(struct seq_file *seq, void *v)
1876 spin_unlock_bh(&ax25_list_lock);
1879 static int ax25_info_show(struct seq_file *seq, void *v)
1888 * 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
1891 seq_printf(seq, "%8.8lx %s %s%s ",
1893 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1894 ax2asc(buf, &ax25->source_addr),
1895 ax25->iamdigi? "*":"");
1896 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1898 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1899 seq_printf(seq, ",%s%s",
1900 ax2asc(buf, &ax25->digipeat->calls[k]),
1901 ax25->digipeat->repeated[k]? "*":"");
1904 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1906 ax25->vs, ax25->vr, ax25->va,
1907 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1908 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1909 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1910 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1911 ax25->idle / (60 * HZ),
1912 ax25->n2count, ax25->n2,
1917 if (ax25->sk != NULL) {
1918 bh_lock_sock(ax25->sk);
1919 seq_printf(seq," %d %d %ld\n",
1920 atomic_read(&ax25->sk->sk_wmem_alloc),
1921 atomic_read(&ax25->sk->sk_rmem_alloc),
1922 ax25->sk->sk_socket != NULL ? SOCK_INODE(ax25->sk->sk_socket)->i_ino : 0L);
1923 bh_unlock_sock(ax25->sk);
1925 seq_puts(seq, " * * *\n");
1930 static struct seq_operations ax25_info_seqops = {
1931 .start = ax25_info_start,
1932 .next = ax25_info_next,
1933 .stop = ax25_info_stop,
1934 .show = ax25_info_show,
1937 static int ax25_info_open(struct inode *inode, struct file *file)
1939 return seq_open(file, &ax25_info_seqops);
1942 static struct file_operations ax25_info_fops = {
1943 .owner = THIS_MODULE,
1944 .open = ax25_info_open,
1946 .llseek = seq_lseek,
1947 .release = seq_release,
1952 static struct net_proto_family ax25_family_ops = {
1954 .create = ax25_create,
1955 .owner = THIS_MODULE,
1958 static const struct proto_ops ax25_proto_ops = {
1960 .owner = THIS_MODULE,
1961 .release = ax25_release,
1963 .connect = ax25_connect,
1964 .socketpair = sock_no_socketpair,
1965 .accept = ax25_accept,
1966 .getname = ax25_getname,
1967 .poll = datagram_poll,
1968 .ioctl = ax25_ioctl,
1969 .listen = ax25_listen,
1970 .shutdown = ax25_shutdown,
1971 .setsockopt = ax25_setsockopt,
1972 .getsockopt = ax25_getsockopt,
1973 .sendmsg = ax25_sendmsg,
1974 .recvmsg = ax25_recvmsg,
1975 .mmap = sock_no_mmap,
1976 .sendpage = sock_no_sendpage,
1980 * Called by socket.c on kernel start up
1982 static struct packet_type ax25_packet_type = {
1983 .type = __constant_htons(ETH_P_AX25),
1984 .dev = NULL, /* All devices */
1985 .func = ax25_kiss_rcv,
1988 static struct notifier_block ax25_dev_notifier = {
1989 .notifier_call =ax25_device_event,
1992 static int __init ax25_init(void)
1994 int rc = proto_register(&ax25_proto, 0);
1999 sock_register(&ax25_family_ops);
2000 dev_add_pack(&ax25_packet_type);
2001 register_netdevice_notifier(&ax25_dev_notifier);
2002 ax25_register_sysctl();
2004 proc_net_fops_create("ax25_route", S_IRUGO, &ax25_route_fops);
2005 proc_net_fops_create("ax25", S_IRUGO, &ax25_info_fops);
2006 proc_net_fops_create("ax25_calls", S_IRUGO, &ax25_uid_fops);
2010 module_init(ax25_init);
2013 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2014 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2015 MODULE_LICENSE("GPL");
2016 MODULE_ALIAS_NETPROTO(PF_AX25);
2018 static void __exit ax25_exit(void)
2020 proc_net_remove("ax25_route");
2021 proc_net_remove("ax25");
2022 proc_net_remove("ax25_calls");
2027 ax25_unregister_sysctl();
2028 unregister_netdevice_notifier(&ax25_dev_notifier);
2030 dev_remove_pack(&ax25_packet_type);
2032 sock_unregister(PF_AX25);
2033 proto_unregister(&ax25_proto);
2035 module_exit(ax25_exit);