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 <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/net_namespace.h>
49
#include <net/tcp_states.h>
55
HLIST_HEAD(ax25_list);
56
DEFINE_SPINLOCK(ax25_list_lock);
58
static const struct proto_ops ax25_proto_ops;
60
static void ax25_free_sock(struct sock *sk)
62
ax25_cb_put(ax25_sk(sk));
66
* Socket removal during an interrupt is now safe.
68
static void ax25_cb_del(ax25_cb *ax25)
70
if (!hlist_unhashed(&ax25->ax25_node)) {
71
spin_lock_bh(&ax25_list_lock);
72
hlist_del_init(&ax25->ax25_node);
73
spin_unlock_bh(&ax25_list_lock);
79
* Kill all bound sockets on a dropped device.
81
static void ax25_kill_by_device(struct net_device *dev)
85
struct hlist_node *node;
87
if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
90
spin_lock_bh(&ax25_list_lock);
92
ax25_for_each(s, node, &ax25_list) {
93
if (s->ax25_dev == ax25_dev) {
95
spin_unlock_bh(&ax25_list_lock);
96
ax25_disconnect(s, ENETUNREACH);
97
spin_lock_bh(&ax25_list_lock);
99
/* The entry could have been deleted from the
100
* list meanwhile and thus the next pointer is
101
* no longer valid. Play it safe and restart
102
* the scan. Forward progress is ensured
103
* because we set s->ax25_dev to NULL and we
104
* are never passed a NULL 'dev' argument.
109
spin_unlock_bh(&ax25_list_lock);
113
* Handle device status changes.
115
static int ax25_device_event(struct notifier_block *this, unsigned long event,
118
struct net_device *dev = (struct net_device *)ptr;
120
if (!net_eq(dev_net(dev), &init_net))
123
/* Reject non AX.25 devices */
124
if (dev->type != ARPHRD_AX25)
129
ax25_dev_device_up(dev);
132
ax25_kill_by_device(dev);
133
ax25_rt_device_down(dev);
134
ax25_dev_device_down(dev);
144
* Add a socket to the bound sockets list.
146
void ax25_cb_add(ax25_cb *ax25)
148
spin_lock_bh(&ax25_list_lock);
150
hlist_add_head(&ax25->ax25_node, &ax25_list);
151
spin_unlock_bh(&ax25_list_lock);
155
* Find a socket that wants to accept the SABM we have just
158
struct sock *ax25_find_listener(ax25_address *addr, int digi,
159
struct net_device *dev, int type)
162
struct hlist_node *node;
164
spin_lock(&ax25_list_lock);
165
ax25_for_each(s, node, &ax25_list) {
166
if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
168
if (s->sk && !ax25cmp(&s->source_addr, addr) &&
169
s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
170
/* If device is null we match any device */
171
if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
173
spin_unlock(&ax25_list_lock);
178
spin_unlock(&ax25_list_lock);
184
* Find an AX.25 socket given both ends.
186
struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
189
struct sock *sk = NULL;
191
struct hlist_node *node;
193
spin_lock(&ax25_list_lock);
194
ax25_for_each(s, node, &ax25_list) {
195
if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
196
!ax25cmp(&s->dest_addr, dest_addr) &&
197
s->sk->sk_type == type) {
204
spin_unlock(&ax25_list_lock);
210
* Find an AX.25 control block given both ends. It will only pick up
211
* floating AX.25 control blocks or non Raw socket bound control blocks.
213
ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
214
ax25_digi *digi, struct net_device *dev)
217
struct hlist_node *node;
219
spin_lock_bh(&ax25_list_lock);
220
ax25_for_each(s, node, &ax25_list) {
221
if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
223
if (s->ax25_dev == NULL)
225
if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
226
if (digi != NULL && digi->ndigi != 0) {
227
if (s->digipeat == NULL)
229
if (ax25digicmp(s->digipeat, digi) != 0)
232
if (s->digipeat != NULL && s->digipeat->ndigi != 0)
236
spin_unlock_bh(&ax25_list_lock);
241
spin_unlock_bh(&ax25_list_lock);
246
EXPORT_SYMBOL(ax25_find_cb);
248
void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
251
struct sk_buff *copy;
252
struct hlist_node *node;
254
spin_lock(&ax25_list_lock);
255
ax25_for_each(s, node, &ax25_list) {
256
if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
257
s->sk->sk_type == SOCK_RAW &&
258
s->sk->sk_protocol == proto &&
259
s->ax25_dev->dev == skb->dev &&
260
atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
261
if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
263
if (sock_queue_rcv_skb(s->sk, copy) != 0)
267
spin_unlock(&ax25_list_lock);
273
void ax25_destroy_socket(ax25_cb *);
276
* Handler for deferred kills.
278
static void ax25_destroy_timer(unsigned long data)
280
ax25_cb *ax25=(ax25_cb *)data;
287
ax25_destroy_socket(ax25);
293
* This is called from user mode and the timers. Thus it protects itself
294
* against interrupt users but doesn't worry about being called during
295
* work. Once it is removed from the queue no interrupt or bottom half
296
* will touch it and we are (fairly 8-) ) safe.
298
void ax25_destroy_socket(ax25_cb *ax25)
304
ax25_stop_heartbeat(ax25);
305
ax25_stop_t1timer(ax25);
306
ax25_stop_t2timer(ax25);
307
ax25_stop_t3timer(ax25);
308
ax25_stop_idletimer(ax25);
310
ax25_clear_queues(ax25); /* Flush the queues */
312
if (ax25->sk != NULL) {
313
while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
314
if (skb->sk != ax25->sk) {
315
/* A pending connection */
316
ax25_cb *sax25 = ax25_sk(skb->sk);
318
/* Queue the unaccepted socket for death */
319
sock_orphan(skb->sk);
321
/* 9A4GL: hack to release unaccepted sockets */
322
skb->sk->sk_state = TCP_LISTEN;
324
ax25_start_heartbeat(sax25);
325
sax25->state = AX25_STATE_0;
330
skb_queue_purge(&ax25->sk->sk_write_queue);
333
if (ax25->sk != NULL) {
334
if (sk_has_allocations(ax25->sk)) {
335
/* Defer: outstanding buffers */
336
setup_timer(&ax25->dtimer, ax25_destroy_timer,
337
(unsigned long)ax25);
338
ax25->dtimer.expires = jiffies + 2 * HZ;
339
add_timer(&ax25->dtimer);
341
struct sock *sk=ax25->sk;
351
* dl1bke 960311: set parameters for existing AX.25 connections,
352
* includes a KILL command to abort any connection.
353
* VERY useful for debugging ;-)
355
static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
357
struct ax25_ctl_struct ax25_ctl;
364
if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
367
if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
370
if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
373
if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
376
digi.ndigi = ax25_ctl.digi_count;
377
for (k = 0; k < digi.ndigi; k++)
378
digi.calls[k] = ax25_ctl.digi_addr[k];
380
if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
383
switch (ax25_ctl.cmd) {
385
ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
386
#ifdef CONFIG_AX25_DAMA_SLAVE
387
if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
390
ax25_disconnect(ax25, ENETRESET);
394
if (ax25->modulus == AX25_MODULUS) {
395
if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
398
if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
401
ax25->window = ax25_ctl.arg;
405
if (ax25_ctl.arg < 1)
407
ax25->rtt = (ax25_ctl.arg * HZ) / 2;
408
ax25->t1 = ax25_ctl.arg * HZ;
412
if (ax25_ctl.arg < 1)
414
ax25->t2 = ax25_ctl.arg * HZ;
418
if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
421
ax25->n2 = ax25_ctl.arg;
425
ax25->t3 = ax25_ctl.arg * HZ;
429
ax25->idle = ax25_ctl.arg * 60 * HZ;
433
if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
435
ax25->paclen = ax25_ctl.arg;
451
static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
453
ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
454
ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
455
ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
456
ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
457
ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
458
ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
459
ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
460
ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
462
if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
463
ax25->modulus = AX25_EMODULUS;
464
ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
466
ax25->modulus = AX25_MODULUS;
467
ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
472
* Fill in a created AX.25 created control block with the default
473
* values for a particular device.
475
void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
477
ax25->ax25_dev = ax25_dev;
479
if (ax25->ax25_dev != NULL) {
480
ax25_fillin_cb_from_dev(ax25, ax25_dev);
485
* No device, use kernel / AX.25 spec default values
487
ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
488
ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
489
ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
490
ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
491
ax25->n2 = AX25_DEF_N2;
492
ax25->paclen = AX25_DEF_PACLEN;
493
ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
494
ax25->backoff = AX25_DEF_BACKOFF;
496
if (AX25_DEF_AXDEFMODE) {
497
ax25->modulus = AX25_EMODULUS;
498
ax25->window = AX25_DEF_EWINDOW;
500
ax25->modulus = AX25_MODULUS;
501
ax25->window = AX25_DEF_WINDOW;
506
* Create an empty AX.25 control block.
508
ax25_cb *ax25_create_cb(void)
512
if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
515
atomic_set(&ax25->refcount, 1);
517
skb_queue_head_init(&ax25->write_queue);
518
skb_queue_head_init(&ax25->frag_queue);
519
skb_queue_head_init(&ax25->ack_queue);
520
skb_queue_head_init(&ax25->reseq_queue);
522
ax25_setup_timers(ax25);
524
ax25_fillin_cb(ax25, NULL);
526
ax25->state = AX25_STATE_0;
532
* Handling for system calls applied via the various interfaces to an
536
static int ax25_setsockopt(struct socket *sock, int level, int optname,
537
char __user *optval, unsigned int optlen)
539
struct sock *sk = sock->sk;
541
struct net_device *dev;
542
char devname[IFNAMSIZ];
545
if (level != SOL_AX25)
548
if (optlen < sizeof(int))
551
if (get_user(opt, (int __user *)optval))
559
if (ax25->modulus == AX25_MODULUS) {
560
if (opt < 1 || opt > 7) {
565
if (opt < 1 || opt > 63) {
578
ax25->rtt = (opt * HZ) >> 1;
591
if (opt < 1 || opt > 31) {
611
ax25->idle = opt * 60 * HZ;
615
if (opt < 0 || opt > 2) {
623
ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
627
ax25->pidincl = opt ? 1 : 0;
631
ax25->iamdigi = opt ? 1 : 0;
635
if (opt < 16 || opt > 65535) {
642
case SO_BINDTODEVICE:
643
if (optlen > IFNAMSIZ)
646
if (copy_from_user(devname, optval, optlen)) {
651
if (sk->sk_type == SOCK_SEQPACKET &&
652
(sock->state != SS_UNCONNECTED ||
653
sk->sk_state == TCP_LISTEN)) {
654
res = -EADDRNOTAVAIL;
658
dev = dev_get_by_name(&init_net, devname);
664
ax25->ax25_dev = ax25_dev_ax25dev(dev);
665
ax25_fillin_cb(ax25, ax25->ax25_dev);
677
static int ax25_getsockopt(struct socket *sock, int level, int optname,
678
char __user *optval, int __user *optlen)
680
struct sock *sk = sock->sk;
682
struct ax25_dev *ax25_dev;
683
char devname[IFNAMSIZ];
688
if (level != SOL_AX25)
691
if (get_user(maxlen, optlen))
697
valptr = (void *) &val;
698
length = min_t(unsigned int, maxlen, sizeof(int));
725
val = ax25->idle / (60 * HZ);
733
val = (ax25->modulus == AX25_EMODULUS);
748
case SO_BINDTODEVICE:
749
ax25_dev = ax25->ax25_dev;
751
if (ax25_dev != NULL && ax25_dev->dev != NULL) {
752
strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
753
length = strlen(devname) + 1;
759
valptr = (void *) devname;
768
if (put_user(length, optlen))
771
return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
774
static int ax25_listen(struct socket *sock, int backlog)
776
struct sock *sk = sock->sk;
780
if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
781
sk->sk_max_ack_backlog = backlog;
782
sk->sk_state = TCP_LISTEN;
794
* XXX: when creating ax25_sock we should update the .obj_size setting
797
static struct proto ax25_proto = {
799
.owner = THIS_MODULE,
800
.obj_size = sizeof(struct sock),
803
static int ax25_create(struct net *net, struct socket *sock, int protocol,
809
if (!net_eq(net, &init_net))
810
return -EAFNOSUPPORT;
812
switch (sock->type) {
814
if (protocol == 0 || protocol == PF_AX25)
815
protocol = AX25_P_TEXT;
821
case PF_AX25: /* For CLX */
822
protocol = AX25_P_TEXT;
835
return -ESOCKTNOSUPPORT;
836
#ifdef CONFIG_NETROM_MODULE
838
if (ax25_protocol_is_registered(AX25_P_NETROM))
839
return -ESOCKTNOSUPPORT;
841
#ifdef CONFIG_ROSE_MODULE
843
if (ax25_protocol_is_registered(AX25_P_ROSE))
844
return -ESOCKTNOSUPPORT;
854
return -ESOCKTNOSUPPORT;
857
sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
861
ax25 = sk->sk_protinfo = ax25_create_cb();
867
sock_init_data(sock, sk);
869
sk->sk_destruct = ax25_free_sock;
870
sock->ops = &ax25_proto_ops;
871
sk->sk_protocol = protocol;
878
struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
881
ax25_cb *ax25, *oax25;
883
sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
887
if ((ax25 = ax25_create_cb()) == NULL) {
892
switch (osk->sk_type) {
903
sock_init_data(NULL, sk);
905
sk->sk_type = osk->sk_type;
906
sk->sk_priority = osk->sk_priority;
907
sk->sk_protocol = osk->sk_protocol;
908
sk->sk_rcvbuf = osk->sk_rcvbuf;
909
sk->sk_sndbuf = osk->sk_sndbuf;
910
sk->sk_state = TCP_ESTABLISHED;
911
sock_copy_flags(sk, osk);
913
oax25 = ax25_sk(osk);
915
ax25->modulus = oax25->modulus;
916
ax25->backoff = oax25->backoff;
917
ax25->pidincl = oax25->pidincl;
918
ax25->iamdigi = oax25->iamdigi;
919
ax25->rtt = oax25->rtt;
920
ax25->t1 = oax25->t1;
921
ax25->t2 = oax25->t2;
922
ax25->t3 = oax25->t3;
923
ax25->n2 = oax25->n2;
924
ax25->idle = oax25->idle;
925
ax25->paclen = oax25->paclen;
926
ax25->window = oax25->window;
928
ax25->ax25_dev = ax25_dev;
929
ax25->source_addr = oax25->source_addr;
931
if (oax25->digipeat != NULL) {
932
ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
934
if (ax25->digipeat == NULL) {
941
sk->sk_protinfo = ax25;
942
sk->sk_destruct = ax25_free_sock;
948
static int ax25_release(struct socket *sock)
950
struct sock *sk = sock->sk;
961
if (sk->sk_type == SOCK_SEQPACKET) {
962
switch (ax25->state) {
965
ax25_disconnect(ax25, 0);
967
ax25_destroy_socket(ax25);
972
ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
974
ax25_disconnect(ax25, 0);
976
ax25_destroy_socket(ax25);
981
ax25_clear_queues(ax25);
984
switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
985
case AX25_PROTO_STD_SIMPLEX:
986
case AX25_PROTO_STD_DUPLEX:
987
ax25_send_control(ax25,
991
ax25_stop_t2timer(ax25);
992
ax25_stop_t3timer(ax25);
993
ax25_stop_idletimer(ax25);
995
#ifdef CONFIG_AX25_DAMA_SLAVE
996
case AX25_PROTO_DAMA_SLAVE:
997
ax25_stop_t3timer(ax25);
998
ax25_stop_idletimer(ax25);
1002
ax25_calculate_t1(ax25);
1003
ax25_start_t1timer(ax25);
1004
ax25->state = AX25_STATE_2;
1005
sk->sk_state = TCP_CLOSE;
1006
sk->sk_shutdown |= SEND_SHUTDOWN;
1007
sk->sk_state_change(sk);
1008
sock_set_flag(sk, SOCK_DESTROY);
1015
sk->sk_state = TCP_CLOSE;
1016
sk->sk_shutdown |= SEND_SHUTDOWN;
1017
sk->sk_state_change(sk);
1018
ax25_destroy_socket(ax25);
1029
* We support a funny extension here so you can (as root) give any callsign
1030
* digipeated via a local address as source. This hack is obsolete now
1031
* that we've implemented support for SO_BINDTODEVICE. It is however small
1032
* and trivially backward compatible.
1034
static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1036
struct sock *sk = sock->sk;
1037
struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1038
ax25_dev *ax25_dev = NULL;
1039
ax25_uid_assoc *user;
1044
if (addr_len != sizeof(struct sockaddr_ax25) &&
1045
addr_len != sizeof(struct full_sockaddr_ax25))
1046
/* support for old structure may go away some time
1047
* ax25_bind(): uses old (6 digipeater) socket structure.
1049
if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1050
(addr_len > sizeof(struct full_sockaddr_ax25)))
1053
if (addr->fsa_ax25.sax25_family != AF_AX25)
1056
user = ax25_findbyuid(current_euid());
1061
if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1064
call = addr->fsa_ax25.sax25_call;
1070
if (!sock_flag(sk, SOCK_ZAPPED)) {
1075
ax25->source_addr = call;
1078
* User already set interface with SO_BINDTODEVICE
1080
if (ax25->ax25_dev != NULL)
1083
if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1084
if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1085
(ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1086
err = -EADDRNOTAVAIL;
1090
if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1091
err = -EADDRNOTAVAIL;
1096
if (ax25_dev != NULL)
1097
ax25_fillin_cb(ax25, ax25_dev);
1101
sock_reset_flag(sk, SOCK_ZAPPED);
1110
* FIXME: nonblock behaviour looks like it may have a bug.
1112
static int __must_check ax25_connect(struct socket *sock,
1113
struct sockaddr *uaddr, int addr_len, int flags)
1115
struct sock *sk = sock->sk;
1116
ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1117
struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1118
ax25_digi *digi = NULL;
1119
int ct = 0, err = 0;
1122
* some sanity checks. code further down depends on this
1125
if (addr_len == sizeof(struct sockaddr_ax25))
1126
/* support for this will go away in early 2.5.x
1127
* ax25_connect(): uses obsolete socket structure
1130
else if (addr_len != sizeof(struct full_sockaddr_ax25))
1131
/* support for old structure may go away some time
1132
* ax25_connect(): uses old (6 digipeater) socket structure.
1134
if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1135
(addr_len > sizeof(struct full_sockaddr_ax25)))
1139
if (fsa->fsa_ax25.sax25_family != AF_AX25)
1144
/* deal with restarts */
1145
if (sock->state == SS_CONNECTING) {
1146
switch (sk->sk_state) {
1147
case TCP_SYN_SENT: /* still trying */
1151
case TCP_ESTABLISHED: /* connection established */
1152
sock->state = SS_CONNECTED;
1155
case TCP_CLOSE: /* connection refused */
1156
sock->state = SS_UNCONNECTED;
1157
err = -ECONNREFUSED;
1162
if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1163
err = -EISCONN; /* No reconnect on a seqpacket socket */
1167
sk->sk_state = TCP_CLOSE;
1168
sock->state = SS_UNCONNECTED;
1170
kfree(ax25->digipeat);
1171
ax25->digipeat = NULL;
1174
* Handle digi-peaters to be used.
1176
if (addr_len > sizeof(struct sockaddr_ax25) &&
1177
fsa->fsa_ax25.sax25_ndigis != 0) {
1178
/* Valid number of digipeaters ? */
1179
if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1184
if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1189
digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1190
digi->lastrepeat = -1;
1192
while (ct < fsa->fsa_ax25.sax25_ndigis) {
1193
if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1194
AX25_HBIT) && ax25->iamdigi) {
1195
digi->repeated[ct] = 1;
1196
digi->lastrepeat = ct;
1198
digi->repeated[ct] = 0;
1200
digi->calls[ct] = fsa->fsa_digipeater[ct];
1206
* Must bind first - autobinding in this may or may not work. If
1207
* the socket is already bound, check to see if the device has
1208
* been filled in, error if it hasn't.
1210
if (sock_flag(sk, SOCK_ZAPPED)) {
1211
/* check if we can remove this feature. It is broken. */
1212
printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1214
if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1219
ax25_fillin_cb(ax25, ax25->ax25_dev);
1222
if (ax25->ax25_dev == NULL) {
1224
err = -EHOSTUNREACH;
1229
if (sk->sk_type == SOCK_SEQPACKET &&
1230
(ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1231
ax25->ax25_dev->dev))) {
1233
err = -EADDRINUSE; /* Already such a connection */
1238
ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1239
ax25->digipeat = digi;
1241
/* First the easy one */
1242
if (sk->sk_type != SOCK_SEQPACKET) {
1243
sock->state = SS_CONNECTED;
1244
sk->sk_state = TCP_ESTABLISHED;
1248
/* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1249
sock->state = SS_CONNECTING;
1250
sk->sk_state = TCP_SYN_SENT;
1252
switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1253
case AX25_PROTO_STD_SIMPLEX:
1254
case AX25_PROTO_STD_DUPLEX:
1255
ax25_std_establish_data_link(ax25);
1258
#ifdef CONFIG_AX25_DAMA_SLAVE
1259
case AX25_PROTO_DAMA_SLAVE:
1260
ax25->modulus = AX25_MODULUS;
1261
ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1262
if (ax25->ax25_dev->dama.slave)
1263
ax25_ds_establish_data_link(ax25);
1265
ax25_std_establish_data_link(ax25);
1270
ax25->state = AX25_STATE_1;
1272
ax25_start_heartbeat(ax25);
1275
if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1280
if (sk->sk_state == TCP_SYN_SENT) {
1284
prepare_to_wait(sk_sleep(sk), &wait,
1285
TASK_INTERRUPTIBLE);
1286
if (sk->sk_state != TCP_SYN_SENT)
1288
if (!signal_pending(current)) {
1297
finish_wait(sk_sleep(sk), &wait);
1303
if (sk->sk_state != TCP_ESTABLISHED) {
1304
/* Not in ABM, not in WAIT_UA -> failed */
1305
sock->state = SS_UNCONNECTED;
1306
err = sock_error(sk); /* Always set at this point */
1310
sock->state = SS_CONNECTED;
1319
static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1321
struct sk_buff *skb;
1327
if (sock->state != SS_UNCONNECTED)
1330
if ((sk = sock->sk) == NULL)
1334
if (sk->sk_type != SOCK_SEQPACKET) {
1339
if (sk->sk_state != TCP_LISTEN) {
1345
* The read queue this time is holding sockets ready to use
1346
* hooked into the SABM we saved
1349
prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1350
skb = skb_dequeue(&sk->sk_receive_queue);
1354
if (flags & O_NONBLOCK) {
1358
if (!signal_pending(current)) {
1367
finish_wait(sk_sleep(sk), &wait);
1373
sock_graft(newsk, newsock);
1375
/* Now attach up the new socket */
1377
sk->sk_ack_backlog--;
1378
newsock->state = SS_CONNECTED;
1386
static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1387
int *uaddr_len, int peer)
1389
struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1390
struct sock *sk = sock->sk;
1391
unsigned char ndigi, i;
1395
memset(fsa, 0, sizeof(*fsa));
1400
if (sk->sk_state != TCP_ESTABLISHED) {
1405
fsa->fsa_ax25.sax25_family = AF_AX25;
1406
fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1408
if (ax25->digipeat != NULL) {
1409
ndigi = ax25->digipeat->ndigi;
1410
fsa->fsa_ax25.sax25_ndigis = ndigi;
1411
for (i = 0; i < ndigi; i++)
1412
fsa->fsa_digipeater[i] =
1413
ax25->digipeat->calls[i];
1416
fsa->fsa_ax25.sax25_family = AF_AX25;
1417
fsa->fsa_ax25.sax25_call = ax25->source_addr;
1418
fsa->fsa_ax25.sax25_ndigis = 1;
1419
if (ax25->ax25_dev != NULL) {
1420
memcpy(&fsa->fsa_digipeater[0],
1421
ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1423
fsa->fsa_digipeater[0] = null_ax25_address;
1426
*uaddr_len = sizeof (struct full_sockaddr_ax25);
1434
static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1435
struct msghdr *msg, size_t len)
1437
struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1438
struct sock *sk = sock->sk;
1439
struct sockaddr_ax25 sax;
1440
struct sk_buff *skb;
1441
ax25_digi dtmp, *dp;
1444
int lv, err, addr_len = msg->msg_namelen;
1446
if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1452
if (sock_flag(sk, SOCK_ZAPPED)) {
1453
err = -EADDRNOTAVAIL;
1457
if (sk->sk_shutdown & SEND_SHUTDOWN) {
1458
send_sig(SIGPIPE, current, 0);
1463
if (ax25->ax25_dev == NULL) {
1468
if (len > ax25->ax25_dev->dev->mtu) {
1474
if (usax->sax25_family != AF_AX25) {
1479
if (addr_len == sizeof(struct sockaddr_ax25))
1480
/* ax25_sendmsg(): uses obsolete socket structure */
1482
else if (addr_len != sizeof(struct full_sockaddr_ax25))
1483
/* support for old structure may go away some time
1484
* ax25_sendmsg(): uses old (6 digipeater)
1487
if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1488
(addr_len > sizeof(struct full_sockaddr_ax25))) {
1494
if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1496
struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1498
/* Valid number of digipeaters ? */
1499
if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1504
dtmp.ndigi = usax->sax25_ndigis;
1506
while (ct < usax->sax25_ndigis) {
1507
dtmp.repeated[ct] = 0;
1508
dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1512
dtmp.lastrepeat = 0;
1516
if (sk->sk_type == SOCK_SEQPACKET &&
1517
ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1521
if (usax->sax25_ndigis == 0)
1527
* FIXME: 1003.1g - if the socket is like this because
1528
* it has become closed (not started closed) and is VC
1529
* we ought to SIGPIPE, EPIPE
1531
if (sk->sk_state != TCP_ESTABLISHED) {
1535
sax.sax25_family = AF_AX25;
1536
sax.sax25_call = ax25->dest_addr;
1537
dp = ax25->digipeat;
1540
/* Build a packet */
1541
/* Assume the worst case */
1542
size = len + ax25->ax25_dev->dev->hard_header_len;
1544
skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1548
skb_reserve(skb, size - len);
1550
/* User data follows immediately after the AX.25 data */
1551
if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
1557
skb_reset_network_header(skb);
1559
/* Add the PID if one is not supplied by the user in the skb */
1561
*skb_push(skb, 1) = sk->sk_protocol;
1563
if (sk->sk_type == SOCK_SEQPACKET) {
1564
/* Connected mode sockets go via the LAPB machine */
1565
if (sk->sk_state != TCP_ESTABLISHED) {
1571
/* Shove it onto the queue and kick */
1572
ax25_output(ax25, ax25->paclen, skb);
1578
skb_push(skb, 1 + ax25_addr_size(dp));
1580
/* Building AX.25 Header */
1582
/* Build an AX.25 header */
1583
lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1584
dp, AX25_COMMAND, AX25_MODULUS);
1586
skb_set_transport_header(skb, lv);
1588
*skb_transport_header(skb) = AX25_UI;
1590
/* Datagram frames go straight out of the door as UI */
1591
ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1601
static int ax25_recvmsg(struct kiocb *iocb, struct socket *sock,
1602
struct msghdr *msg, size_t size, int flags)
1604
struct sock *sk = sock->sk;
1605
struct sk_buff *skb;
1611
* This works for seqpacket too. The receiver has ordered the
1612
* queue for us! We do one quick check first though
1614
if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1619
/* Now we can treat all alike */
1620
skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1621
flags & MSG_DONTWAIT, &err);
1625
if (!ax25_sk(sk)->pidincl)
1626
skb_pull(skb, 1); /* Remove PID */
1628
skb_reset_transport_header(skb);
1631
if (copied > size) {
1633
msg->msg_flags |= MSG_TRUNC;
1636
skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1638
if (msg->msg_namelen != 0) {
1639
struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1642
const unsigned char *mac = skb_mac_header(skb);
1644
ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1646
sax->sax25_family = AF_AX25;
1647
/* We set this correctly, even though we may not let the
1648
application know the digi calls further down (because it
1649
did NOT ask to know them). This could get political... **/
1650
sax->sax25_ndigis = digi.ndigi;
1651
sax->sax25_call = src;
1653
if (sax->sax25_ndigis != 0) {
1655
struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1657
for (ct = 0; ct < digi.ndigi; ct++)
1658
fsa->fsa_digipeater[ct] = digi.calls[ct];
1660
msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1663
skb_free_datagram(sk, skb);
1672
static int ax25_shutdown(struct socket *sk, int how)
1674
/* FIXME - generate DM and RNR states */
1678
static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1680
struct sock *sk = sock->sk;
1681
void __user *argp = (void __user *)arg;
1689
amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1692
res = put_user(amount, (int __user *)argp);
1697
struct sk_buff *skb;
1699
/* These two are safe on a single CPU system as only user tasks fiddle here */
1700
if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1702
res = put_user(amount, (int __user *) argp);
1707
res = sock_get_timestamp(sk, argp);
1711
res = sock_get_timestampns(sk, argp);
1714
case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1715
case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1716
case SIOCAX25GETUID: {
1717
struct sockaddr_ax25 sax25;
1718
if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1722
res = ax25_uid_ioctl(cmd, &sax25);
1726
case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1728
if (!capable(CAP_NET_ADMIN)) {
1732
if (get_user(amount, (long __user *)argp)) {
1736
if (amount > AX25_NOUID_BLOCK) {
1740
ax25_uid_policy = amount;
1748
if (!capable(CAP_NET_ADMIN)) {
1752
res = ax25_rt_ioctl(cmd, argp);
1755
case SIOCAX25CTLCON:
1756
if (!capable(CAP_NET_ADMIN)) {
1760
res = ax25_ctl_ioctl(cmd, argp);
1763
case SIOCAX25GETINFO:
1764
case SIOCAX25GETINFOOLD: {
1765
ax25_cb *ax25 = ax25_sk(sk);
1766
struct ax25_info_struct ax25_info;
1768
ax25_info.t1 = ax25->t1 / HZ;
1769
ax25_info.t2 = ax25->t2 / HZ;
1770
ax25_info.t3 = ax25->t3 / HZ;
1771
ax25_info.idle = ax25->idle / (60 * HZ);
1772
ax25_info.n2 = ax25->n2;
1773
ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1774
ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1775
ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1776
ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1777
ax25_info.n2count = ax25->n2count;
1778
ax25_info.state = ax25->state;
1779
ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1780
ax25_info.snd_q = sk_wmem_alloc_get(sk);
1781
ax25_info.vs = ax25->vs;
1782
ax25_info.vr = ax25->vr;
1783
ax25_info.va = ax25->va;
1784
ax25_info.vs_max = ax25->vs; /* reserved */
1785
ax25_info.paclen = ax25->paclen;
1786
ax25_info.window = ax25->window;
1788
/* old structure? */
1789
if (cmd == SIOCAX25GETINFOOLD) {
1790
static int warned = 0;
1792
printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1797
if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1802
if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1811
case SIOCAX25ADDFWD:
1812
case SIOCAX25DELFWD: {
1813
struct ax25_fwd_struct ax25_fwd;
1814
if (!capable(CAP_NET_ADMIN)) {
1818
if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1822
res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1828
case SIOCGIFDSTADDR:
1829
case SIOCSIFDSTADDR:
1830
case SIOCGIFBRDADDR:
1831
case SIOCSIFBRDADDR:
1832
case SIOCGIFNETMASK:
1833
case SIOCSIFNETMASK:
1848
#ifdef CONFIG_PROC_FS
1850
static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1851
__acquires(ax25_list_lock)
1853
spin_lock_bh(&ax25_list_lock);
1854
return seq_hlist_start(&ax25_list, *pos);
1857
static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1859
return seq_hlist_next(v, &ax25_list, pos);
1862
static void ax25_info_stop(struct seq_file *seq, void *v)
1863
__releases(ax25_list_lock)
1865
spin_unlock_bh(&ax25_list_lock);
1868
static int ax25_info_show(struct seq_file *seq, void *v)
1870
ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1877
* 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
1880
seq_printf(seq, "%8.8lx %s %s%s ",
1882
ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1883
ax2asc(buf, &ax25->source_addr),
1884
ax25->iamdigi? "*":"");
1885
seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1887
for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1888
seq_printf(seq, ",%s%s",
1889
ax2asc(buf, &ax25->digipeat->calls[k]),
1890
ax25->digipeat->repeated[k]? "*":"");
1893
seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1895
ax25->vs, ax25->vr, ax25->va,
1896
ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1897
ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1898
ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1899
ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1900
ax25->idle / (60 * HZ),
1901
ax25->n2count, ax25->n2,
1906
if (ax25->sk != NULL) {
1907
seq_printf(seq, " %d %d %lu\n",
1908
sk_wmem_alloc_get(ax25->sk),
1909
sk_rmem_alloc_get(ax25->sk),
1910
sock_i_ino(ax25->sk));
1912
seq_puts(seq, " * * *\n");
1917
static const struct seq_operations ax25_info_seqops = {
1918
.start = ax25_info_start,
1919
.next = ax25_info_next,
1920
.stop = ax25_info_stop,
1921
.show = ax25_info_show,
1924
static int ax25_info_open(struct inode *inode, struct file *file)
1926
return seq_open(file, &ax25_info_seqops);
1929
static const struct file_operations ax25_info_fops = {
1930
.owner = THIS_MODULE,
1931
.open = ax25_info_open,
1933
.llseek = seq_lseek,
1934
.release = seq_release,
1939
static const struct net_proto_family ax25_family_ops = {
1941
.create = ax25_create,
1942
.owner = THIS_MODULE,
1945
static const struct proto_ops ax25_proto_ops = {
1947
.owner = THIS_MODULE,
1948
.release = ax25_release,
1950
.connect = ax25_connect,
1951
.socketpair = sock_no_socketpair,
1952
.accept = ax25_accept,
1953
.getname = ax25_getname,
1954
.poll = datagram_poll,
1955
.ioctl = ax25_ioctl,
1956
.listen = ax25_listen,
1957
.shutdown = ax25_shutdown,
1958
.setsockopt = ax25_setsockopt,
1959
.getsockopt = ax25_getsockopt,
1960
.sendmsg = ax25_sendmsg,
1961
.recvmsg = ax25_recvmsg,
1962
.mmap = sock_no_mmap,
1963
.sendpage = sock_no_sendpage,
1967
* Called by socket.c on kernel start up
1969
static struct packet_type ax25_packet_type __read_mostly = {
1970
.type = cpu_to_be16(ETH_P_AX25),
1971
.func = ax25_kiss_rcv,
1974
static struct notifier_block ax25_dev_notifier = {
1975
.notifier_call =ax25_device_event,
1978
static int __init ax25_init(void)
1980
int rc = proto_register(&ax25_proto, 0);
1985
sock_register(&ax25_family_ops);
1986
dev_add_pack(&ax25_packet_type);
1987
register_netdevice_notifier(&ax25_dev_notifier);
1988
ax25_register_sysctl();
1990
proc_net_fops_create(&init_net, "ax25_route", S_IRUGO, &ax25_route_fops);
1991
proc_net_fops_create(&init_net, "ax25", S_IRUGO, &ax25_info_fops);
1992
proc_net_fops_create(&init_net, "ax25_calls", S_IRUGO, &ax25_uid_fops);
1996
module_init(ax25_init);
1999
MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2000
MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2001
MODULE_LICENSE("GPL");
2002
MODULE_ALIAS_NETPROTO(PF_AX25);
2004
static void __exit ax25_exit(void)
2006
proc_net_remove(&init_net, "ax25_route");
2007
proc_net_remove(&init_net, "ax25");
2008
proc_net_remove(&init_net, "ax25_calls");
2013
ax25_unregister_sysctl();
2014
unregister_netdevice_notifier(&ax25_dev_notifier);
2016
dev_remove_pack(&ax25_packet_type);
2018
sock_unregister(PF_AX25);
2019
proto_unregister(&ax25_proto);
2021
module_exit(ax25_exit);