2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
7 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
8 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
10 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
11 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
12 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
13 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
14 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
16 #include <linux/capability.h>
17 #include <linux/module.h>
18 #include <linux/errno.h>
19 #include <linux/types.h>
20 #include <linux/socket.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <linux/slab.h>
30 #include <linux/inet.h>
31 #include <linux/netdevice.h>
32 #include <linux/if_arp.h>
33 #include <linux/skbuff.h>
35 #include <asm/uaccess.h>
36 #include <linux/fcntl.h>
37 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
39 #include <linux/interrupt.h>
40 #include <linux/notifier.h>
41 #include <linux/proc_fs.h>
42 #include <linux/stat.h>
43 #include <linux/sysctl.h>
44 #include <linux/init.h>
45 #include <linux/spinlock.h>
46 #include <net/net_namespace.h>
47 #include <net/tcp_states.h>
53 HLIST_HEAD(ax25_list);
54 DEFINE_SPINLOCK(ax25_list_lock);
56 static const struct proto_ops ax25_proto_ops;
58 static void ax25_free_sock(struct sock *sk)
60 ax25_cb_put(sk_to_ax25(sk));
64 * Socket removal during an interrupt is now safe.
66 static void ax25_cb_del(ax25_cb *ax25)
68 if (!hlist_unhashed(&ax25->ax25_node)) {
69 spin_lock_bh(&ax25_list_lock);
70 hlist_del_init(&ax25->ax25_node);
71 spin_unlock_bh(&ax25_list_lock);
77 * Kill all bound sockets on a dropped device.
79 static void ax25_kill_by_device(struct net_device *dev)
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);
96 ax25_disconnect(s, ENETUNREACH);
97 spin_lock_bh(&ax25_list_lock);
101 spin_unlock_bh(&ax25_list_lock);
105 ax25_disconnect(s, ENETUNREACH);
106 spin_lock_bh(&ax25_list_lock);
108 /* The entry could have been deleted from the
109 * list meanwhile and thus the next pointer is
110 * no longer valid. Play it safe and restart
111 * the scan. Forward progress is ensured
112 * because we set s->ax25_dev to NULL and we
113 * are never passed a NULL 'dev' argument.
118 spin_unlock_bh(&ax25_list_lock);
122 * Handle device status changes.
124 static int ax25_device_event(struct notifier_block *this, unsigned long event,
127 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
129 if (!net_eq(dev_net(dev), &init_net))
132 /* Reject non AX.25 devices */
133 if (dev->type != ARPHRD_AX25)
138 ax25_dev_device_up(dev);
141 ax25_kill_by_device(dev);
142 ax25_rt_device_down(dev);
143 ax25_dev_device_down(dev);
153 * Add a socket to the bound sockets list.
155 void ax25_cb_add(ax25_cb *ax25)
157 spin_lock_bh(&ax25_list_lock);
159 hlist_add_head(&ax25->ax25_node, &ax25_list);
160 spin_unlock_bh(&ax25_list_lock);
164 * Find a socket that wants to accept the SABM we have just
167 struct sock *ax25_find_listener(ax25_address *addr, int digi,
168 struct net_device *dev, int type)
172 spin_lock(&ax25_list_lock);
173 ax25_for_each(s, &ax25_list) {
174 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
176 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
177 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
178 /* If device is null we match any device */
179 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
181 spin_unlock(&ax25_list_lock);
186 spin_unlock(&ax25_list_lock);
192 * Find an AX.25 socket given both ends.
194 struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
197 struct sock *sk = NULL;
200 spin_lock(&ax25_list_lock);
201 ax25_for_each(s, &ax25_list) {
202 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
203 !ax25cmp(&s->dest_addr, dest_addr) &&
204 s->sk->sk_type == type) {
211 spin_unlock(&ax25_list_lock);
217 * Find an AX.25 control block given both ends. It will only pick up
218 * floating AX.25 control blocks or non Raw socket bound control blocks.
220 ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
221 ax25_digi *digi, struct net_device *dev)
225 spin_lock_bh(&ax25_list_lock);
226 ax25_for_each(s, &ax25_list) {
227 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
229 if (s->ax25_dev == NULL)
231 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
232 if (digi != NULL && digi->ndigi != 0) {
233 if (s->digipeat == NULL)
235 if (ax25digicmp(s->digipeat, digi) != 0)
238 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
242 spin_unlock_bh(&ax25_list_lock);
247 spin_unlock_bh(&ax25_list_lock);
252 EXPORT_SYMBOL(ax25_find_cb);
254 void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
257 struct sk_buff *copy;
259 spin_lock(&ax25_list_lock);
260 ax25_for_each(s, &ax25_list) {
261 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
262 s->sk->sk_type == SOCK_RAW &&
263 s->sk->sk_protocol == proto &&
264 s->ax25_dev->dev == skb->dev &&
265 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
266 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
268 if (sock_queue_rcv_skb(s->sk, copy) != 0)
272 spin_unlock(&ax25_list_lock);
278 void ax25_destroy_socket(ax25_cb *);
281 * Handler for deferred kills.
283 static void ax25_destroy_timer(unsigned long data)
285 ax25_cb *ax25=(ax25_cb *)data;
292 ax25_destroy_socket(ax25);
298 * This is called from user mode and the timers. Thus it protects itself
299 * against interrupt users but doesn't worry about being called during
300 * work. Once it is removed from the queue no interrupt or bottom half
301 * will touch it and we are (fairly 8-) ) safe.
303 void ax25_destroy_socket(ax25_cb *ax25)
309 ax25_stop_heartbeat(ax25);
310 ax25_stop_t1timer(ax25);
311 ax25_stop_t2timer(ax25);
312 ax25_stop_t3timer(ax25);
313 ax25_stop_idletimer(ax25);
315 ax25_clear_queues(ax25); /* Flush the queues */
317 if (ax25->sk != NULL) {
318 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
319 if (skb->sk != ax25->sk) {
320 /* A pending connection */
321 ax25_cb *sax25 = sk_to_ax25(skb->sk);
323 /* Queue the unaccepted socket for death */
324 sock_orphan(skb->sk);
326 /* 9A4GL: hack to release unaccepted sockets */
327 skb->sk->sk_state = TCP_LISTEN;
329 ax25_start_heartbeat(sax25);
330 sax25->state = AX25_STATE_0;
335 skb_queue_purge(&ax25->sk->sk_write_queue);
338 if (ax25->sk != NULL) {
339 if (sk_has_allocations(ax25->sk)) {
340 /* Defer: outstanding buffers */
341 setup_timer(&ax25->dtimer, ax25_destroy_timer,
342 (unsigned long)ax25);
343 ax25->dtimer.expires = jiffies + 2 * HZ;
344 add_timer(&ax25->dtimer);
346 struct sock *sk=ax25->sk;
356 * dl1bke 960311: set parameters for existing AX.25 connections,
357 * includes a KILL command to abort any connection.
358 * VERY useful for debugging ;-)
360 static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
362 struct ax25_ctl_struct ax25_ctl;
369 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
372 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
375 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
378 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
381 digi.ndigi = ax25_ctl.digi_count;
382 for (k = 0; k < digi.ndigi; k++)
383 digi.calls[k] = ax25_ctl.digi_addr[k];
385 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
388 switch (ax25_ctl.cmd) {
390 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
391 #ifdef CONFIG_AX25_DAMA_SLAVE
392 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
395 ax25_disconnect(ax25, ENETRESET);
399 if (ax25->modulus == AX25_MODULUS) {
400 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
403 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
406 ax25->window = ax25_ctl.arg;
410 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
412 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
413 ax25->t1 = ax25_ctl.arg * HZ;
417 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
419 ax25->t2 = ax25_ctl.arg * HZ;
423 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
426 ax25->n2 = ax25_ctl.arg;
430 if (ax25_ctl.arg > ULONG_MAX / HZ)
432 ax25->t3 = ax25_ctl.arg * HZ;
436 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
439 ax25->idle = ax25_ctl.arg * 60 * HZ;
443 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
445 ax25->paclen = ax25_ctl.arg;
461 static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
463 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
464 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
465 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
466 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
467 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
468 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
469 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
470 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
472 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
473 ax25->modulus = AX25_EMODULUS;
474 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
476 ax25->modulus = AX25_MODULUS;
477 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
482 * Fill in a created AX.25 created control block with the default
483 * values for a particular device.
485 void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
487 ax25->ax25_dev = ax25_dev;
489 if (ax25->ax25_dev != NULL) {
490 ax25_fillin_cb_from_dev(ax25, ax25_dev);
495 * No device, use kernel / AX.25 spec default values
497 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
498 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
499 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
500 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
501 ax25->n2 = AX25_DEF_N2;
502 ax25->paclen = AX25_DEF_PACLEN;
503 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
504 ax25->backoff = AX25_DEF_BACKOFF;
506 if (AX25_DEF_AXDEFMODE) {
507 ax25->modulus = AX25_EMODULUS;
508 ax25->window = AX25_DEF_EWINDOW;
510 ax25->modulus = AX25_MODULUS;
511 ax25->window = AX25_DEF_WINDOW;
516 * Create an empty AX.25 control block.
518 ax25_cb *ax25_create_cb(void)
522 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
525 atomic_set(&ax25->refcount, 1);
527 skb_queue_head_init(&ax25->write_queue);
528 skb_queue_head_init(&ax25->frag_queue);
529 skb_queue_head_init(&ax25->ack_queue);
530 skb_queue_head_init(&ax25->reseq_queue);
532 ax25_setup_timers(ax25);
534 ax25_fillin_cb(ax25, NULL);
536 ax25->state = AX25_STATE_0;
542 * Handling for system calls applied via the various interfaces to an
546 static int ax25_setsockopt(struct socket *sock, int level, int optname,
547 char __user *optval, unsigned int optlen)
549 struct sock *sk = sock->sk;
551 struct net_device *dev;
552 char devname[IFNAMSIZ];
556 if (level != SOL_AX25)
559 if (optlen < sizeof(unsigned int))
562 if (get_user(opt, (unsigned int __user *)optval))
566 ax25 = sk_to_ax25(sk);
570 if (ax25->modulus == AX25_MODULUS) {
571 if (opt < 1 || opt > 7) {
576 if (opt < 1 || opt > 63) {
585 if (opt < 1 || opt > ULONG_MAX / HZ) {
589 ax25->rtt = (opt * HZ) >> 1;
594 if (opt < 1 || opt > ULONG_MAX / HZ) {
602 if (opt < 1 || opt > 31) {
610 if (opt < 1 || opt > ULONG_MAX / HZ) {
618 if (opt > ULONG_MAX / (60 * HZ)) {
622 ax25->idle = opt * 60 * HZ;
634 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
638 ax25->pidincl = opt ? 1 : 0;
642 ax25->iamdigi = opt ? 1 : 0;
646 if (opt < 16 || opt > 65535) {
653 case SO_BINDTODEVICE:
654 if (optlen > IFNAMSIZ - 1)
655 optlen = IFNAMSIZ - 1;
657 memset(devname, 0, sizeof(devname));
659 if (copy_from_user(devname, optval, optlen)) {
664 if (sk->sk_type == SOCK_SEQPACKET &&
665 (sock->state != SS_UNCONNECTED ||
666 sk->sk_state == TCP_LISTEN)) {
667 res = -EADDRNOTAVAIL;
672 dev = __dev_get_by_name(&init_net, devname);
679 ax25->ax25_dev = ax25_dev_ax25dev(dev);
680 if (!ax25->ax25_dev) {
685 ax25_fillin_cb(ax25, ax25->ax25_dev);
697 static int ax25_getsockopt(struct socket *sock, int level, int optname,
698 char __user *optval, int __user *optlen)
700 struct sock *sk = sock->sk;
702 struct ax25_dev *ax25_dev;
703 char devname[IFNAMSIZ];
708 if (level != SOL_AX25)
711 if (get_user(maxlen, optlen))
717 valptr = (void *) &val;
718 length = min_t(unsigned int, maxlen, sizeof(int));
721 ax25 = sk_to_ax25(sk);
745 val = ax25->idle / (60 * HZ);
753 val = (ax25->modulus == AX25_EMODULUS);
768 case SO_BINDTODEVICE:
769 ax25_dev = ax25->ax25_dev;
771 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
772 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
773 length = strlen(devname) + 1;
779 valptr = (void *) devname;
788 if (put_user(length, optlen))
791 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
794 static int ax25_listen(struct socket *sock, int backlog)
796 struct sock *sk = sock->sk;
800 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
801 sk->sk_max_ack_backlog = backlog;
802 sk->sk_state = TCP_LISTEN;
814 * XXX: when creating ax25_sock we should update the .obj_size setting
817 static struct proto ax25_proto = {
819 .owner = THIS_MODULE,
820 .obj_size = sizeof(struct ax25_sock),
823 static int ax25_create(struct net *net, struct socket *sock, int protocol,
829 if (protocol < 0 || protocol > SK_PROTOCOL_MAX)
832 if (!net_eq(net, &init_net))
833 return -EAFNOSUPPORT;
835 switch (sock->type) {
837 if (protocol == 0 || protocol == PF_AX25)
838 protocol = AX25_P_TEXT;
844 case PF_AX25: /* For CLX */
845 protocol = AX25_P_TEXT;
858 return -ESOCKTNOSUPPORT;
859 #ifdef CONFIG_NETROM_MODULE
861 if (ax25_protocol_is_registered(AX25_P_NETROM))
862 return -ESOCKTNOSUPPORT;
865 #ifdef CONFIG_ROSE_MODULE
867 if (ax25_protocol_is_registered(AX25_P_ROSE))
868 return -ESOCKTNOSUPPORT;
876 if (!capable(CAP_NET_RAW))
880 return -ESOCKTNOSUPPORT;
883 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
887 ax25 = ax25_sk(sk)->cb = ax25_create_cb();
893 sock_init_data(sock, sk);
895 sk->sk_destruct = ax25_free_sock;
896 sock->ops = &ax25_proto_ops;
897 sk->sk_protocol = protocol;
904 struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
907 ax25_cb *ax25, *oax25;
909 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
913 if ((ax25 = ax25_create_cb()) == NULL) {
918 switch (osk->sk_type) {
929 sock_init_data(NULL, sk);
931 sk->sk_type = osk->sk_type;
932 sk->sk_priority = osk->sk_priority;
933 sk->sk_protocol = osk->sk_protocol;
934 sk->sk_rcvbuf = osk->sk_rcvbuf;
935 sk->sk_sndbuf = osk->sk_sndbuf;
936 sk->sk_state = TCP_ESTABLISHED;
937 sock_copy_flags(sk, osk);
939 oax25 = sk_to_ax25(osk);
941 ax25->modulus = oax25->modulus;
942 ax25->backoff = oax25->backoff;
943 ax25->pidincl = oax25->pidincl;
944 ax25->iamdigi = oax25->iamdigi;
945 ax25->rtt = oax25->rtt;
946 ax25->t1 = oax25->t1;
947 ax25->t2 = oax25->t2;
948 ax25->t3 = oax25->t3;
949 ax25->n2 = oax25->n2;
950 ax25->idle = oax25->idle;
951 ax25->paclen = oax25->paclen;
952 ax25->window = oax25->window;
954 ax25->ax25_dev = ax25_dev;
955 ax25->source_addr = oax25->source_addr;
957 if (oax25->digipeat != NULL) {
958 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
960 if (ax25->digipeat == NULL) {
967 ax25_sk(sk)->cb = ax25;
968 sk->sk_destruct = ax25_free_sock;
974 static int ax25_release(struct socket *sock)
976 struct sock *sk = sock->sk;
985 ax25 = sk_to_ax25(sk);
987 if (sk->sk_type == SOCK_SEQPACKET) {
988 switch (ax25->state) {
991 ax25_disconnect(ax25, 0);
993 ax25_destroy_socket(ax25);
998 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
1000 ax25_disconnect(ax25, 0);
1002 if (!sock_flag(ax25->sk, SOCK_DESTROY))
1003 ax25_destroy_socket(ax25);
1008 ax25_clear_queues(ax25);
1011 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1012 case AX25_PROTO_STD_SIMPLEX:
1013 case AX25_PROTO_STD_DUPLEX:
1014 ax25_send_control(ax25,
1018 ax25_stop_t2timer(ax25);
1019 ax25_stop_t3timer(ax25);
1020 ax25_stop_idletimer(ax25);
1022 #ifdef CONFIG_AX25_DAMA_SLAVE
1023 case AX25_PROTO_DAMA_SLAVE:
1024 ax25_stop_t3timer(ax25);
1025 ax25_stop_idletimer(ax25);
1029 ax25_calculate_t1(ax25);
1030 ax25_start_t1timer(ax25);
1031 ax25->state = AX25_STATE_2;
1032 sk->sk_state = TCP_CLOSE;
1033 sk->sk_shutdown |= SEND_SHUTDOWN;
1034 sk->sk_state_change(sk);
1035 sock_set_flag(sk, SOCK_DESTROY);
1042 sk->sk_state = TCP_CLOSE;
1043 sk->sk_shutdown |= SEND_SHUTDOWN;
1044 sk->sk_state_change(sk);
1045 ax25_destroy_socket(ax25);
1056 * We support a funny extension here so you can (as root) give any callsign
1057 * digipeated via a local address as source. This hack is obsolete now
1058 * that we've implemented support for SO_BINDTODEVICE. It is however small
1059 * and trivially backward compatible.
1061 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1063 struct sock *sk = sock->sk;
1064 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1065 ax25_dev *ax25_dev = NULL;
1066 ax25_uid_assoc *user;
1071 if (addr_len != sizeof(struct sockaddr_ax25) &&
1072 addr_len != sizeof(struct full_sockaddr_ax25))
1073 /* support for old structure may go away some time
1074 * ax25_bind(): uses old (6 digipeater) socket structure.
1076 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1077 (addr_len > sizeof(struct full_sockaddr_ax25)))
1080 if (addr->fsa_ax25.sax25_family != AF_AX25)
1083 user = ax25_findbyuid(current_euid());
1088 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1091 call = addr->fsa_ax25.sax25_call;
1096 ax25 = sk_to_ax25(sk);
1097 if (!sock_flag(sk, SOCK_ZAPPED)) {
1102 ax25->source_addr = call;
1105 * User already set interface with SO_BINDTODEVICE
1107 if (ax25->ax25_dev != NULL)
1110 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1111 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1112 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1113 err = -EADDRNOTAVAIL;
1117 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1118 err = -EADDRNOTAVAIL;
1123 if (ax25_dev != NULL)
1124 ax25_fillin_cb(ax25, ax25_dev);
1128 sock_reset_flag(sk, SOCK_ZAPPED);
1137 * FIXME: nonblock behaviour looks like it may have a bug.
1139 static int __must_check ax25_connect(struct socket *sock,
1140 struct sockaddr *uaddr, int addr_len, int flags)
1142 struct sock *sk = sock->sk;
1143 ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1144 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1145 ax25_digi *digi = NULL;
1146 int ct = 0, err = 0;
1149 * some sanity checks. code further down depends on this
1152 if (addr_len == sizeof(struct sockaddr_ax25))
1153 /* support for this will go away in early 2.5.x
1154 * ax25_connect(): uses obsolete socket structure
1157 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1158 /* support for old structure may go away some time
1159 * ax25_connect(): uses old (6 digipeater) socket structure.
1161 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1162 (addr_len > sizeof(struct full_sockaddr_ax25)))
1166 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1171 /* deal with restarts */
1172 if (sock->state == SS_CONNECTING) {
1173 switch (sk->sk_state) {
1174 case TCP_SYN_SENT: /* still trying */
1178 case TCP_ESTABLISHED: /* connection established */
1179 sock->state = SS_CONNECTED;
1182 case TCP_CLOSE: /* connection refused */
1183 sock->state = SS_UNCONNECTED;
1184 err = -ECONNREFUSED;
1189 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1190 err = -EISCONN; /* No reconnect on a seqpacket socket */
1194 sk->sk_state = TCP_CLOSE;
1195 sock->state = SS_UNCONNECTED;
1197 kfree(ax25->digipeat);
1198 ax25->digipeat = NULL;
1201 * Handle digi-peaters to be used.
1203 if (addr_len > sizeof(struct sockaddr_ax25) &&
1204 fsa->fsa_ax25.sax25_ndigis != 0) {
1205 /* Valid number of digipeaters ? */
1206 if (fsa->fsa_ax25.sax25_ndigis < 1 ||
1207 fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS ||
1208 addr_len < sizeof(struct sockaddr_ax25) +
1209 sizeof(ax25_address) * fsa->fsa_ax25.sax25_ndigis) {
1214 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1219 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1220 digi->lastrepeat = -1;
1222 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1223 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1224 AX25_HBIT) && ax25->iamdigi) {
1225 digi->repeated[ct] = 1;
1226 digi->lastrepeat = ct;
1228 digi->repeated[ct] = 0;
1230 digi->calls[ct] = fsa->fsa_digipeater[ct];
1236 * Must bind first - autobinding in this may or may not work. If
1237 * the socket is already bound, check to see if the device has
1238 * been filled in, error if it hasn't.
1240 if (sock_flag(sk, SOCK_ZAPPED)) {
1241 /* check if we can remove this feature. It is broken. */
1242 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1244 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1249 ax25_fillin_cb(ax25, ax25->ax25_dev);
1252 if (ax25->ax25_dev == NULL) {
1254 err = -EHOSTUNREACH;
1259 if (sk->sk_type == SOCK_SEQPACKET &&
1260 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1261 ax25->ax25_dev->dev))) {
1263 err = -EADDRINUSE; /* Already such a connection */
1268 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1269 ax25->digipeat = digi;
1271 /* First the easy one */
1272 if (sk->sk_type != SOCK_SEQPACKET) {
1273 sock->state = SS_CONNECTED;
1274 sk->sk_state = TCP_ESTABLISHED;
1278 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1279 sock->state = SS_CONNECTING;
1280 sk->sk_state = TCP_SYN_SENT;
1282 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1283 case AX25_PROTO_STD_SIMPLEX:
1284 case AX25_PROTO_STD_DUPLEX:
1285 ax25_std_establish_data_link(ax25);
1288 #ifdef CONFIG_AX25_DAMA_SLAVE
1289 case AX25_PROTO_DAMA_SLAVE:
1290 ax25->modulus = AX25_MODULUS;
1291 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1292 if (ax25->ax25_dev->dama.slave)
1293 ax25_ds_establish_data_link(ax25);
1295 ax25_std_establish_data_link(ax25);
1300 ax25->state = AX25_STATE_1;
1302 ax25_start_heartbeat(ax25);
1305 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1310 if (sk->sk_state == TCP_SYN_SENT) {
1314 prepare_to_wait(sk_sleep(sk), &wait,
1315 TASK_INTERRUPTIBLE);
1316 if (sk->sk_state != TCP_SYN_SENT)
1318 if (!signal_pending(current)) {
1327 finish_wait(sk_sleep(sk), &wait);
1333 if (sk->sk_state != TCP_ESTABLISHED) {
1334 /* Not in ABM, not in WAIT_UA -> failed */
1335 sock->state = SS_UNCONNECTED;
1336 err = sock_error(sk); /* Always set at this point */
1340 sock->state = SS_CONNECTED;
1349 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1351 struct sk_buff *skb;
1357 if (sock->state != SS_UNCONNECTED)
1360 if ((sk = sock->sk) == NULL)
1364 if (sk->sk_type != SOCK_SEQPACKET) {
1369 if (sk->sk_state != TCP_LISTEN) {
1375 * The read queue this time is holding sockets ready to use
1376 * hooked into the SABM we saved
1379 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1380 skb = skb_dequeue(&sk->sk_receive_queue);
1384 if (flags & O_NONBLOCK) {
1388 if (!signal_pending(current)) {
1397 finish_wait(sk_sleep(sk), &wait);
1403 sock_graft(newsk, newsock);
1405 /* Now attach up the new socket */
1407 sk->sk_ack_backlog--;
1408 newsock->state = SS_CONNECTED;
1416 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1417 int *uaddr_len, int peer)
1419 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1420 struct sock *sk = sock->sk;
1421 unsigned char ndigi, i;
1425 memset(fsa, 0, sizeof(*fsa));
1427 ax25 = sk_to_ax25(sk);
1430 if (sk->sk_state != TCP_ESTABLISHED) {
1435 fsa->fsa_ax25.sax25_family = AF_AX25;
1436 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1438 if (ax25->digipeat != NULL) {
1439 ndigi = ax25->digipeat->ndigi;
1440 fsa->fsa_ax25.sax25_ndigis = ndigi;
1441 for (i = 0; i < ndigi; i++)
1442 fsa->fsa_digipeater[i] =
1443 ax25->digipeat->calls[i];
1446 fsa->fsa_ax25.sax25_family = AF_AX25;
1447 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1448 fsa->fsa_ax25.sax25_ndigis = 1;
1449 if (ax25->ax25_dev != NULL) {
1450 memcpy(&fsa->fsa_digipeater[0],
1451 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1453 fsa->fsa_digipeater[0] = null_ax25_address;
1456 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1464 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1466 DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1467 struct sock *sk = sock->sk;
1468 struct sockaddr_ax25 sax;
1469 struct sk_buff *skb;
1470 ax25_digi dtmp, *dp;
1473 int lv, err, addr_len = msg->msg_namelen;
1475 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1479 ax25 = sk_to_ax25(sk);
1481 if (sock_flag(sk, SOCK_ZAPPED)) {
1482 err = -EADDRNOTAVAIL;
1486 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1487 send_sig(SIGPIPE, current, 0);
1492 if (ax25->ax25_dev == NULL) {
1497 if (len > ax25->ax25_dev->dev->mtu) {
1503 if (usax->sax25_family != AF_AX25) {
1508 if (addr_len == sizeof(struct sockaddr_ax25))
1509 /* ax25_sendmsg(): uses obsolete socket structure */
1511 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1512 /* support for old structure may go away some time
1513 * ax25_sendmsg(): uses old (6 digipeater)
1516 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1517 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1523 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1525 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1527 /* Valid number of digipeaters ? */
1528 if (usax->sax25_ndigis < 1 ||
1529 usax->sax25_ndigis > AX25_MAX_DIGIS ||
1530 addr_len < sizeof(struct sockaddr_ax25) +
1531 sizeof(ax25_address) * usax->sax25_ndigis) {
1536 dtmp.ndigi = usax->sax25_ndigis;
1538 while (ct < usax->sax25_ndigis) {
1539 dtmp.repeated[ct] = 0;
1540 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1544 dtmp.lastrepeat = 0;
1548 if (sk->sk_type == SOCK_SEQPACKET &&
1549 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1553 if (usax->sax25_ndigis == 0)
1559 * FIXME: 1003.1g - if the socket is like this because
1560 * it has become closed (not started closed) and is VC
1561 * we ought to SIGPIPE, EPIPE
1563 if (sk->sk_state != TCP_ESTABLISHED) {
1567 sax.sax25_family = AF_AX25;
1568 sax.sax25_call = ax25->dest_addr;
1569 dp = ax25->digipeat;
1572 /* Build a packet */
1573 /* Assume the worst case */
1574 size = len + ax25->ax25_dev->dev->hard_header_len;
1576 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1580 skb_reserve(skb, size - len);
1582 /* User data follows immediately after the AX.25 data */
1583 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1589 skb_reset_network_header(skb);
1591 /* Add the PID if one is not supplied by the user in the skb */
1593 *skb_push(skb, 1) = sk->sk_protocol;
1595 if (sk->sk_type == SOCK_SEQPACKET) {
1596 /* Connected mode sockets go via the LAPB machine */
1597 if (sk->sk_state != TCP_ESTABLISHED) {
1603 /* Shove it onto the queue and kick */
1604 ax25_output(ax25, ax25->paclen, skb);
1610 skb_push(skb, 1 + ax25_addr_size(dp));
1612 /* Building AX.25 Header */
1614 /* Build an AX.25 header */
1615 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1616 dp, AX25_COMMAND, AX25_MODULUS);
1618 skb_set_transport_header(skb, lv);
1620 *skb_transport_header(skb) = AX25_UI;
1622 /* Datagram frames go straight out of the door as UI */
1623 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1633 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1636 struct sock *sk = sock->sk;
1637 struct sk_buff *skb;
1643 * This works for seqpacket too. The receiver has ordered the
1644 * queue for us! We do one quick check first though
1646 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1651 /* Now we can treat all alike */
1652 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1653 flags & MSG_DONTWAIT, &err);
1657 if (!sk_to_ax25(sk)->pidincl)
1658 skb_pull(skb, 1); /* Remove PID */
1660 skb_reset_transport_header(skb);
1663 if (copied > size) {
1665 msg->msg_flags |= MSG_TRUNC;
1668 skb_copy_datagram_msg(skb, 0, msg, copied);
1670 if (msg->msg_name) {
1673 const unsigned char *mac = skb_mac_header(skb);
1674 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1676 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1677 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1679 sax->sax25_family = AF_AX25;
1680 /* We set this correctly, even though we may not let the
1681 application know the digi calls further down (because it
1682 did NOT ask to know them). This could get political... **/
1683 sax->sax25_ndigis = digi.ndigi;
1684 sax->sax25_call = src;
1686 if (sax->sax25_ndigis != 0) {
1688 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1690 for (ct = 0; ct < digi.ndigi; ct++)
1691 fsa->fsa_digipeater[ct] = digi.calls[ct];
1693 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1696 skb_free_datagram(sk, skb);
1705 static int ax25_shutdown(struct socket *sk, int how)
1707 /* FIXME - generate DM and RNR states */
1711 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1713 struct sock *sk = sock->sk;
1714 void __user *argp = (void __user *)arg;
1722 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1725 res = put_user(amount, (int __user *)argp);
1730 struct sk_buff *skb;
1732 /* These two are safe on a single CPU system as only user tasks fiddle here */
1733 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1735 res = put_user(amount, (int __user *) argp);
1740 res = sock_get_timestamp(sk, argp);
1744 res = sock_get_timestampns(sk, argp);
1747 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1748 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1749 case SIOCAX25GETUID: {
1750 struct sockaddr_ax25 sax25;
1751 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1755 res = ax25_uid_ioctl(cmd, &sax25);
1759 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1761 if (!capable(CAP_NET_ADMIN)) {
1765 if (get_user(amount, (long __user *)argp)) {
1769 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1773 ax25_uid_policy = amount;
1781 if (!capable(CAP_NET_ADMIN)) {
1785 res = ax25_rt_ioctl(cmd, argp);
1788 case SIOCAX25CTLCON:
1789 if (!capable(CAP_NET_ADMIN)) {
1793 res = ax25_ctl_ioctl(cmd, argp);
1796 case SIOCAX25GETINFO:
1797 case SIOCAX25GETINFOOLD: {
1798 ax25_cb *ax25 = sk_to_ax25(sk);
1799 struct ax25_info_struct ax25_info;
1801 ax25_info.t1 = ax25->t1 / HZ;
1802 ax25_info.t2 = ax25->t2 / HZ;
1803 ax25_info.t3 = ax25->t3 / HZ;
1804 ax25_info.idle = ax25->idle / (60 * HZ);
1805 ax25_info.n2 = ax25->n2;
1806 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1807 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1808 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1809 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1810 ax25_info.n2count = ax25->n2count;
1811 ax25_info.state = ax25->state;
1812 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1813 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1814 ax25_info.vs = ax25->vs;
1815 ax25_info.vr = ax25->vr;
1816 ax25_info.va = ax25->va;
1817 ax25_info.vs_max = ax25->vs; /* reserved */
1818 ax25_info.paclen = ax25->paclen;
1819 ax25_info.window = ax25->window;
1821 /* old structure? */
1822 if (cmd == SIOCAX25GETINFOOLD) {
1823 static int warned = 0;
1825 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1830 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1835 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1844 case SIOCAX25ADDFWD:
1845 case SIOCAX25DELFWD: {
1846 struct ax25_fwd_struct ax25_fwd;
1847 if (!capable(CAP_NET_ADMIN)) {
1851 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1855 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1861 case SIOCGIFDSTADDR:
1862 case SIOCSIFDSTADDR:
1863 case SIOCGIFBRDADDR:
1864 case SIOCSIFBRDADDR:
1865 case SIOCGIFNETMASK:
1866 case SIOCSIFNETMASK:
1881 #ifdef CONFIG_PROC_FS
1883 static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1884 __acquires(ax25_list_lock)
1886 spin_lock_bh(&ax25_list_lock);
1887 return seq_hlist_start(&ax25_list, *pos);
1890 static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1892 return seq_hlist_next(v, &ax25_list, pos);
1895 static void ax25_info_stop(struct seq_file *seq, void *v)
1896 __releases(ax25_list_lock)
1898 spin_unlock_bh(&ax25_list_lock);
1901 static int ax25_info_show(struct seq_file *seq, void *v)
1903 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1910 * 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
1913 seq_printf(seq, "%8.8lx %s %s%s ",
1915 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1916 ax2asc(buf, &ax25->source_addr),
1917 ax25->iamdigi? "*":"");
1918 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1920 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1921 seq_printf(seq, ",%s%s",
1922 ax2asc(buf, &ax25->digipeat->calls[k]),
1923 ax25->digipeat->repeated[k]? "*":"");
1926 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1928 ax25->vs, ax25->vr, ax25->va,
1929 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1930 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1931 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1932 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1933 ax25->idle / (60 * HZ),
1934 ax25->n2count, ax25->n2,
1939 if (ax25->sk != NULL) {
1940 seq_printf(seq, " %d %d %lu\n",
1941 sk_wmem_alloc_get(ax25->sk),
1942 sk_rmem_alloc_get(ax25->sk),
1943 sock_i_ino(ax25->sk));
1945 seq_puts(seq, " * * *\n");
1950 static const struct seq_operations ax25_info_seqops = {
1951 .start = ax25_info_start,
1952 .next = ax25_info_next,
1953 .stop = ax25_info_stop,
1954 .show = ax25_info_show,
1957 static int ax25_info_open(struct inode *inode, struct file *file)
1959 return seq_open(file, &ax25_info_seqops);
1962 static const struct file_operations ax25_info_fops = {
1963 .owner = THIS_MODULE,
1964 .open = ax25_info_open,
1966 .llseek = seq_lseek,
1967 .release = seq_release,
1972 static const struct net_proto_family ax25_family_ops = {
1974 .create = ax25_create,
1975 .owner = THIS_MODULE,
1978 static const struct proto_ops ax25_proto_ops = {
1980 .owner = THIS_MODULE,
1981 .release = ax25_release,
1983 .connect = ax25_connect,
1984 .socketpair = sock_no_socketpair,
1985 .accept = ax25_accept,
1986 .getname = ax25_getname,
1987 .poll = datagram_poll,
1988 .ioctl = ax25_ioctl,
1989 .listen = ax25_listen,
1990 .shutdown = ax25_shutdown,
1991 .setsockopt = ax25_setsockopt,
1992 .getsockopt = ax25_getsockopt,
1993 .sendmsg = ax25_sendmsg,
1994 .recvmsg = ax25_recvmsg,
1995 .mmap = sock_no_mmap,
1996 .sendpage = sock_no_sendpage,
2000 * Called by socket.c on kernel start up
2002 static struct packet_type ax25_packet_type __read_mostly = {
2003 .type = cpu_to_be16(ETH_P_AX25),
2004 .func = ax25_kiss_rcv,
2007 static struct notifier_block ax25_dev_notifier = {
2008 .notifier_call = ax25_device_event,
2011 static int __init ax25_init(void)
2013 int rc = proto_register(&ax25_proto, 0);
2018 sock_register(&ax25_family_ops);
2019 dev_add_pack(&ax25_packet_type);
2020 register_netdevice_notifier(&ax25_dev_notifier);
2022 proc_create("ax25_route", S_IRUGO, init_net.proc_net,
2024 proc_create("ax25", S_IRUGO, init_net.proc_net, &ax25_info_fops);
2025 proc_create("ax25_calls", S_IRUGO, init_net.proc_net, &ax25_uid_fops);
2029 module_init(ax25_init);
2032 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2033 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2034 MODULE_LICENSE("GPL");
2035 MODULE_ALIAS_NETPROTO(PF_AX25);
2037 static void __exit ax25_exit(void)
2039 remove_proc_entry("ax25_route", init_net.proc_net);
2040 remove_proc_entry("ax25", init_net.proc_net);
2041 remove_proc_entry("ax25_calls", init_net.proc_net);
2043 unregister_netdevice_notifier(&ax25_dev_notifier);
2045 dev_remove_pack(&ax25_packet_type);
2047 sock_unregister(PF_AX25);
2048 proto_unregister(&ax25_proto);
2054 module_exit(ax25_exit);