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/netfilter.h>
44 #include <linux/sysctl.h>
45 #include <linux/init.h>
46 #include <linux/spinlock.h>
47 #include <net/net_namespace.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
);
91 ax25_for_each(s
, node
, &ax25_list
) {
92 if (s
->ax25_dev
== ax25_dev
) {
94 spin_unlock_bh(&ax25_list_lock
);
95 ax25_disconnect(s
, ENETUNREACH
);
96 spin_lock_bh(&ax25_list_lock
);
98 /* The entry could have been deleted from the
99 * list meanwhile and thus the next pointer is
100 * no longer valid. Play it safe and restart
101 * the scan. Forward progress is ensured
102 * because we set s->ax25_dev to NULL and we
103 * are never passed a NULL 'dev' argument.
108 spin_unlock_bh(&ax25_list_lock
);
112 * Handle device status changes.
114 static int ax25_device_event(struct notifier_block
*this, unsigned long event
,
117 struct net_device
*dev
= (struct net_device
*)ptr
;
119 if (!net_eq(dev_net(dev
), &init_net
))
122 /* Reject non AX.25 devices */
123 if (dev
->type
!= ARPHRD_AX25
)
128 ax25_dev_device_up(dev
);
131 ax25_kill_by_device(dev
);
132 ax25_rt_device_down(dev
);
133 ax25_dev_device_down(dev
);
143 * Add a socket to the bound sockets list.
145 void ax25_cb_add(ax25_cb
*ax25
)
147 spin_lock_bh(&ax25_list_lock
);
149 hlist_add_head(&ax25
->ax25_node
, &ax25_list
);
150 spin_unlock_bh(&ax25_list_lock
);
154 * Find a socket that wants to accept the SABM we have just
157 struct sock
*ax25_find_listener(ax25_address
*addr
, int digi
,
158 struct net_device
*dev
, int type
)
161 struct hlist_node
*node
;
163 spin_lock(&ax25_list_lock
);
164 ax25_for_each(s
, node
, &ax25_list
) {
165 if ((s
->iamdigi
&& !digi
) || (!s
->iamdigi
&& digi
))
167 if (s
->sk
&& !ax25cmp(&s
->source_addr
, addr
) &&
168 s
->sk
->sk_type
== type
&& s
->sk
->sk_state
== TCP_LISTEN
) {
169 /* If device is null we match any device */
170 if (s
->ax25_dev
== NULL
|| s
->ax25_dev
->dev
== dev
) {
172 spin_unlock(&ax25_list_lock
);
177 spin_unlock(&ax25_list_lock
);
183 * Find an AX.25 socket given both ends.
185 struct sock
*ax25_get_socket(ax25_address
*my_addr
, ax25_address
*dest_addr
,
188 struct sock
*sk
= NULL
;
190 struct hlist_node
*node
;
192 spin_lock(&ax25_list_lock
);
193 ax25_for_each(s
, node
, &ax25_list
) {
194 if (s
->sk
&& !ax25cmp(&s
->source_addr
, my_addr
) &&
195 !ax25cmp(&s
->dest_addr
, dest_addr
) &&
196 s
->sk
->sk_type
== type
) {
203 spin_unlock(&ax25_list_lock
);
209 * Find an AX.25 control block given both ends. It will only pick up
210 * floating AX.25 control blocks or non Raw socket bound control blocks.
212 ax25_cb
*ax25_find_cb(ax25_address
*src_addr
, ax25_address
*dest_addr
,
213 ax25_digi
*digi
, struct net_device
*dev
)
216 struct hlist_node
*node
;
218 spin_lock_bh(&ax25_list_lock
);
219 ax25_for_each(s
, node
, &ax25_list
) {
220 if (s
->sk
&& s
->sk
->sk_type
!= SOCK_SEQPACKET
)
222 if (s
->ax25_dev
== NULL
)
224 if (ax25cmp(&s
->source_addr
, src_addr
) == 0 && ax25cmp(&s
->dest_addr
, dest_addr
) == 0 && s
->ax25_dev
->dev
== dev
) {
225 if (digi
!= NULL
&& digi
->ndigi
!= 0) {
226 if (s
->digipeat
== NULL
)
228 if (ax25digicmp(s
->digipeat
, digi
) != 0)
231 if (s
->digipeat
!= NULL
&& s
->digipeat
->ndigi
!= 0)
235 spin_unlock_bh(&ax25_list_lock
);
240 spin_unlock_bh(&ax25_list_lock
);
245 EXPORT_SYMBOL(ax25_find_cb
);
247 void ax25_send_to_raw(ax25_address
*addr
, struct sk_buff
*skb
, int proto
)
250 struct sk_buff
*copy
;
251 struct hlist_node
*node
;
253 spin_lock(&ax25_list_lock
);
254 ax25_for_each(s
, node
, &ax25_list
) {
255 if (s
->sk
!= NULL
&& ax25cmp(&s
->source_addr
, addr
) == 0 &&
256 s
->sk
->sk_type
== SOCK_RAW
&&
257 s
->sk
->sk_protocol
== proto
&&
258 s
->ax25_dev
->dev
== skb
->dev
&&
259 atomic_read(&s
->sk
->sk_rmem_alloc
) <= s
->sk
->sk_rcvbuf
) {
260 if ((copy
= skb_clone(skb
, GFP_ATOMIC
)) == NULL
)
262 if (sock_queue_rcv_skb(s
->sk
, copy
) != 0)
266 spin_unlock(&ax25_list_lock
);
272 void ax25_destroy_socket(ax25_cb
*);
275 * Handler for deferred kills.
277 static void ax25_destroy_timer(unsigned long data
)
279 ax25_cb
*ax25
=(ax25_cb
*)data
;
286 ax25_destroy_socket(ax25
);
292 * This is called from user mode and the timers. Thus it protects itself
293 * against interrupt users but doesn't worry about being called during
294 * work. Once it is removed from the queue no interrupt or bottom half
295 * will touch it and we are (fairly 8-) ) safe.
297 void ax25_destroy_socket(ax25_cb
*ax25
)
303 ax25_stop_heartbeat(ax25
);
304 ax25_stop_t1timer(ax25
);
305 ax25_stop_t2timer(ax25
);
306 ax25_stop_t3timer(ax25
);
307 ax25_stop_idletimer(ax25
);
309 ax25_clear_queues(ax25
); /* Flush the queues */
311 if (ax25
->sk
!= NULL
) {
312 while ((skb
= skb_dequeue(&ax25
->sk
->sk_receive_queue
)) != NULL
) {
313 if (skb
->sk
!= ax25
->sk
) {
314 /* A pending connection */
315 ax25_cb
*sax25
= ax25_sk(skb
->sk
);
317 /* Queue the unaccepted socket for death */
318 sock_orphan(skb
->sk
);
320 /* 9A4GL: hack to release unaccepted sockets */
321 skb
->sk
->sk_state
= TCP_LISTEN
;
323 ax25_start_heartbeat(sax25
);
324 sax25
->state
= AX25_STATE_0
;
329 skb_queue_purge(&ax25
->sk
->sk_write_queue
);
332 if (ax25
->sk
!= NULL
) {
333 if (sk_has_allocations(ax25
->sk
)) {
334 /* Defer: outstanding buffers */
335 setup_timer(&ax25
->dtimer
, ax25_destroy_timer
,
336 (unsigned long)ax25
);
337 ax25
->dtimer
.expires
= jiffies
+ 2 * HZ
;
338 add_timer(&ax25
->dtimer
);
340 struct sock
*sk
=ax25
->sk
;
350 * dl1bke 960311: set parameters for existing AX.25 connections,
351 * includes a KILL command to abort any connection.
352 * VERY useful for debugging ;-)
354 static int ax25_ctl_ioctl(const unsigned int cmd
, void __user
*arg
)
356 struct ax25_ctl_struct ax25_ctl
;
363 if (copy_from_user(&ax25_ctl
, arg
, sizeof(ax25_ctl
)))
366 if ((ax25_dev
= ax25_addr_ax25dev(&ax25_ctl
.port_addr
)) == NULL
)
369 if (ax25_ctl
.digi_count
> AX25_MAX_DIGIS
)
372 if (ax25_ctl
.arg
> ULONG_MAX
/ HZ
&& ax25_ctl
.cmd
!= AX25_KILL
)
375 digi
.ndigi
= ax25_ctl
.digi_count
;
376 for (k
= 0; k
< digi
.ndigi
; k
++)
377 digi
.calls
[k
] = ax25_ctl
.digi_addr
[k
];
379 if ((ax25
= ax25_find_cb(&ax25_ctl
.source_addr
, &ax25_ctl
.dest_addr
, &digi
, ax25_dev
->dev
)) == NULL
)
382 switch (ax25_ctl
.cmd
) {
384 ax25_send_control(ax25
, AX25_DISC
, AX25_POLLON
, AX25_COMMAND
);
385 #ifdef CONFIG_AX25_DAMA_SLAVE
386 if (ax25_dev
->dama
.slave
&& ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
] == AX25_PROTO_DAMA_SLAVE
)
389 ax25_disconnect(ax25
, ENETRESET
);
393 if (ax25
->modulus
== AX25_MODULUS
) {
394 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> 7)
397 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> 63)
400 ax25
->window
= ax25_ctl
.arg
;
404 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> ULONG_MAX
/ HZ
)
406 ax25
->rtt
= (ax25_ctl
.arg
* HZ
) / 2;
407 ax25
->t1
= ax25_ctl
.arg
* HZ
;
411 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> ULONG_MAX
/ HZ
)
413 ax25
->t2
= ax25_ctl
.arg
* HZ
;
417 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> 31)
420 ax25
->n2
= ax25_ctl
.arg
;
424 if (ax25_ctl
.arg
> ULONG_MAX
/ HZ
)
426 ax25
->t3
= ax25_ctl
.arg
* HZ
;
430 if (ax25_ctl
.arg
> ULONG_MAX
/ (60 * HZ
))
433 ax25
->idle
= ax25_ctl
.arg
* 60 * HZ
;
437 if (ax25_ctl
.arg
< 16 || ax25_ctl
.arg
> 65535)
439 ax25
->paclen
= ax25_ctl
.arg
;
455 static void ax25_fillin_cb_from_dev(ax25_cb
*ax25
, ax25_dev
*ax25_dev
)
457 ax25
->rtt
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T1
]) / 2;
458 ax25
->t1
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T1
]);
459 ax25
->t2
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T2
]);
460 ax25
->t3
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T3
]);
461 ax25
->n2
= ax25_dev
->values
[AX25_VALUES_N2
];
462 ax25
->paclen
= ax25_dev
->values
[AX25_VALUES_PACLEN
];
463 ax25
->idle
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_IDLE
]);
464 ax25
->backoff
= ax25_dev
->values
[AX25_VALUES_BACKOFF
];
466 if (ax25_dev
->values
[AX25_VALUES_AXDEFMODE
]) {
467 ax25
->modulus
= AX25_EMODULUS
;
468 ax25
->window
= ax25_dev
->values
[AX25_VALUES_EWINDOW
];
470 ax25
->modulus
= AX25_MODULUS
;
471 ax25
->window
= ax25_dev
->values
[AX25_VALUES_WINDOW
];
476 * Fill in a created AX.25 created control block with the default
477 * values for a particular device.
479 void ax25_fillin_cb(ax25_cb
*ax25
, ax25_dev
*ax25_dev
)
481 ax25
->ax25_dev
= ax25_dev
;
483 if (ax25
->ax25_dev
!= NULL
) {
484 ax25_fillin_cb_from_dev(ax25
, ax25_dev
);
489 * No device, use kernel / AX.25 spec default values
491 ax25
->rtt
= msecs_to_jiffies(AX25_DEF_T1
) / 2;
492 ax25
->t1
= msecs_to_jiffies(AX25_DEF_T1
);
493 ax25
->t2
= msecs_to_jiffies(AX25_DEF_T2
);
494 ax25
->t3
= msecs_to_jiffies(AX25_DEF_T3
);
495 ax25
->n2
= AX25_DEF_N2
;
496 ax25
->paclen
= AX25_DEF_PACLEN
;
497 ax25
->idle
= msecs_to_jiffies(AX25_DEF_IDLE
);
498 ax25
->backoff
= AX25_DEF_BACKOFF
;
500 if (AX25_DEF_AXDEFMODE
) {
501 ax25
->modulus
= AX25_EMODULUS
;
502 ax25
->window
= AX25_DEF_EWINDOW
;
504 ax25
->modulus
= AX25_MODULUS
;
505 ax25
->window
= AX25_DEF_WINDOW
;
510 * Create an empty AX.25 control block.
512 ax25_cb
*ax25_create_cb(void)
516 if ((ax25
= kzalloc(sizeof(*ax25
), GFP_ATOMIC
)) == NULL
)
519 atomic_set(&ax25
->refcount
, 1);
521 skb_queue_head_init(&ax25
->write_queue
);
522 skb_queue_head_init(&ax25
->frag_queue
);
523 skb_queue_head_init(&ax25
->ack_queue
);
524 skb_queue_head_init(&ax25
->reseq_queue
);
526 ax25_setup_timers(ax25
);
528 ax25_fillin_cb(ax25
, NULL
);
530 ax25
->state
= AX25_STATE_0
;
536 * Handling for system calls applied via the various interfaces to an
540 static int ax25_setsockopt(struct socket
*sock
, int level
, int optname
,
541 char __user
*optval
, unsigned int optlen
)
543 struct sock
*sk
= sock
->sk
;
545 struct net_device
*dev
;
546 char devname
[IFNAMSIZ
];
550 if (level
!= SOL_AX25
)
553 if (optlen
< sizeof(unsigned int))
556 if (get_user(opt
, (unsigned int __user
*)optval
))
564 if (ax25
->modulus
== AX25_MODULUS
) {
565 if (opt
< 1 || opt
> 7) {
570 if (opt
< 1 || opt
> 63) {
579 if (opt
< 1 || opt
> ULONG_MAX
/ HZ
) {
583 ax25
->rtt
= (opt
* HZ
) >> 1;
588 if (opt
< 1 || opt
> ULONG_MAX
/ HZ
) {
596 if (opt
< 1 || opt
> 31) {
604 if (opt
< 1 || opt
> ULONG_MAX
/ HZ
) {
612 if (opt
> ULONG_MAX
/ (60 * HZ
)) {
616 ax25
->idle
= opt
* 60 * HZ
;
628 ax25
->modulus
= opt
? AX25_EMODULUS
: AX25_MODULUS
;
632 ax25
->pidincl
= opt
? 1 : 0;
636 ax25
->iamdigi
= opt
? 1 : 0;
640 if (opt
< 16 || opt
> 65535) {
647 case SO_BINDTODEVICE
:
648 if (optlen
> IFNAMSIZ
)
651 if (copy_from_user(devname
, optval
, optlen
)) {
656 if (sk
->sk_type
== SOCK_SEQPACKET
&&
657 (sock
->state
!= SS_UNCONNECTED
||
658 sk
->sk_state
== TCP_LISTEN
)) {
659 res
= -EADDRNOTAVAIL
;
663 dev
= dev_get_by_name(&init_net
, devname
);
669 ax25
->ax25_dev
= ax25_dev_ax25dev(dev
);
670 ax25_fillin_cb(ax25
, ax25
->ax25_dev
);
682 static int ax25_getsockopt(struct socket
*sock
, int level
, int optname
,
683 char __user
*optval
, int __user
*optlen
)
685 struct sock
*sk
= sock
->sk
;
687 struct ax25_dev
*ax25_dev
;
688 char devname
[IFNAMSIZ
];
693 if (level
!= SOL_AX25
)
696 if (get_user(maxlen
, optlen
))
702 valptr
= (void *) &val
;
703 length
= min_t(unsigned int, maxlen
, sizeof(int));
730 val
= ax25
->idle
/ (60 * HZ
);
738 val
= (ax25
->modulus
== AX25_EMODULUS
);
753 case SO_BINDTODEVICE
:
754 ax25_dev
= ax25
->ax25_dev
;
756 if (ax25_dev
!= NULL
&& ax25_dev
->dev
!= NULL
) {
757 strlcpy(devname
, ax25_dev
->dev
->name
, sizeof(devname
));
758 length
= strlen(devname
) + 1;
764 valptr
= (void *) devname
;
773 if (put_user(length
, optlen
))
776 return copy_to_user(optval
, valptr
, length
) ? -EFAULT
: 0;
779 static int ax25_listen(struct socket
*sock
, int backlog
)
781 struct sock
*sk
= sock
->sk
;
785 if (sk
->sk_type
== SOCK_SEQPACKET
&& sk
->sk_state
!= TCP_LISTEN
) {
786 sk
->sk_max_ack_backlog
= backlog
;
787 sk
->sk_state
= TCP_LISTEN
;
799 * XXX: when creating ax25_sock we should update the .obj_size setting
802 static struct proto ax25_proto
= {
804 .owner
= THIS_MODULE
,
805 .obj_size
= sizeof(struct sock
),
808 static int ax25_create(struct net
*net
, struct socket
*sock
, int protocol
,
814 if (!net_eq(net
, &init_net
))
815 return -EAFNOSUPPORT
;
817 switch (sock
->type
) {
819 if (protocol
== 0 || protocol
== PF_AX25
)
820 protocol
= AX25_P_TEXT
;
826 case PF_AX25
: /* For CLX */
827 protocol
= AX25_P_TEXT
;
840 return -ESOCKTNOSUPPORT
;
841 #ifdef CONFIG_NETROM_MODULE
843 if (ax25_protocol_is_registered(AX25_P_NETROM
))
844 return -ESOCKTNOSUPPORT
;
846 #ifdef CONFIG_ROSE_MODULE
848 if (ax25_protocol_is_registered(AX25_P_ROSE
))
849 return -ESOCKTNOSUPPORT
;
859 return -ESOCKTNOSUPPORT
;
862 sk
= sk_alloc(net
, PF_AX25
, GFP_ATOMIC
, &ax25_proto
);
866 ax25
= sk
->sk_protinfo
= ax25_create_cb();
872 sock_init_data(sock
, sk
);
874 sk
->sk_destruct
= ax25_free_sock
;
875 sock
->ops
= &ax25_proto_ops
;
876 sk
->sk_protocol
= protocol
;
883 struct sock
*ax25_make_new(struct sock
*osk
, struct ax25_dev
*ax25_dev
)
886 ax25_cb
*ax25
, *oax25
;
888 sk
= sk_alloc(sock_net(osk
), PF_AX25
, GFP_ATOMIC
, osk
->sk_prot
);
892 if ((ax25
= ax25_create_cb()) == NULL
) {
897 switch (osk
->sk_type
) {
908 sock_init_data(NULL
, sk
);
910 sk
->sk_type
= osk
->sk_type
;
911 sk
->sk_priority
= osk
->sk_priority
;
912 sk
->sk_protocol
= osk
->sk_protocol
;
913 sk
->sk_rcvbuf
= osk
->sk_rcvbuf
;
914 sk
->sk_sndbuf
= osk
->sk_sndbuf
;
915 sk
->sk_state
= TCP_ESTABLISHED
;
916 sock_copy_flags(sk
, osk
);
918 oax25
= ax25_sk(osk
);
920 ax25
->modulus
= oax25
->modulus
;
921 ax25
->backoff
= oax25
->backoff
;
922 ax25
->pidincl
= oax25
->pidincl
;
923 ax25
->iamdigi
= oax25
->iamdigi
;
924 ax25
->rtt
= oax25
->rtt
;
925 ax25
->t1
= oax25
->t1
;
926 ax25
->t2
= oax25
->t2
;
927 ax25
->t3
= oax25
->t3
;
928 ax25
->n2
= oax25
->n2
;
929 ax25
->idle
= oax25
->idle
;
930 ax25
->paclen
= oax25
->paclen
;
931 ax25
->window
= oax25
->window
;
933 ax25
->ax25_dev
= ax25_dev
;
934 ax25
->source_addr
= oax25
->source_addr
;
936 if (oax25
->digipeat
!= NULL
) {
937 ax25
->digipeat
= kmemdup(oax25
->digipeat
, sizeof(ax25_digi
),
939 if (ax25
->digipeat
== NULL
) {
946 sk
->sk_protinfo
= ax25
;
947 sk
->sk_destruct
= ax25_free_sock
;
953 static int ax25_release(struct socket
*sock
)
955 struct sock
*sk
= sock
->sk
;
966 if (sk
->sk_type
== SOCK_SEQPACKET
) {
967 switch (ax25
->state
) {
970 ax25_disconnect(ax25
, 0);
972 ax25_destroy_socket(ax25
);
977 ax25_send_control(ax25
, AX25_DISC
, AX25_POLLON
, AX25_COMMAND
);
979 ax25_disconnect(ax25
, 0);
981 ax25_destroy_socket(ax25
);
986 ax25_clear_queues(ax25
);
989 switch (ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
]) {
990 case AX25_PROTO_STD_SIMPLEX
:
991 case AX25_PROTO_STD_DUPLEX
:
992 ax25_send_control(ax25
,
996 ax25_stop_t2timer(ax25
);
997 ax25_stop_t3timer(ax25
);
998 ax25_stop_idletimer(ax25
);
1000 #ifdef CONFIG_AX25_DAMA_SLAVE
1001 case AX25_PROTO_DAMA_SLAVE
:
1002 ax25_stop_t3timer(ax25
);
1003 ax25_stop_idletimer(ax25
);
1007 ax25_calculate_t1(ax25
);
1008 ax25_start_t1timer(ax25
);
1009 ax25
->state
= AX25_STATE_2
;
1010 sk
->sk_state
= TCP_CLOSE
;
1011 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
1012 sk
->sk_state_change(sk
);
1013 sock_set_flag(sk
, SOCK_DESTROY
);
1020 sk
->sk_state
= TCP_CLOSE
;
1021 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
1022 sk
->sk_state_change(sk
);
1023 ax25_destroy_socket(ax25
);
1034 * We support a funny extension here so you can (as root) give any callsign
1035 * digipeated via a local address as source. This hack is obsolete now
1036 * that we've implemented support for SO_BINDTODEVICE. It is however small
1037 * and trivially backward compatible.
1039 static int ax25_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
1041 struct sock
*sk
= sock
->sk
;
1042 struct full_sockaddr_ax25
*addr
= (struct full_sockaddr_ax25
*)uaddr
;
1043 ax25_dev
*ax25_dev
= NULL
;
1044 ax25_uid_assoc
*user
;
1049 if (addr_len
!= sizeof(struct sockaddr_ax25
) &&
1050 addr_len
!= sizeof(struct full_sockaddr_ax25
))
1051 /* support for old structure may go away some time
1052 * ax25_bind(): uses old (6 digipeater) socket structure.
1054 if ((addr_len
< sizeof(struct sockaddr_ax25
) + sizeof(ax25_address
) * 6) ||
1055 (addr_len
> sizeof(struct full_sockaddr_ax25
)))
1058 if (addr
->fsa_ax25
.sax25_family
!= AF_AX25
)
1061 user
= ax25_findbyuid(current_euid());
1066 if (ax25_uid_policy
&& !capable(CAP_NET_ADMIN
))
1069 call
= addr
->fsa_ax25
.sax25_call
;
1075 if (!sock_flag(sk
, SOCK_ZAPPED
)) {
1080 ax25
->source_addr
= call
;
1083 * User already set interface with SO_BINDTODEVICE
1085 if (ax25
->ax25_dev
!= NULL
)
1088 if (addr_len
> sizeof(struct sockaddr_ax25
) && addr
->fsa_ax25
.sax25_ndigis
== 1) {
1089 if (ax25cmp(&addr
->fsa_digipeater
[0], &null_ax25_address
) != 0 &&
1090 (ax25_dev
= ax25_addr_ax25dev(&addr
->fsa_digipeater
[0])) == NULL
) {
1091 err
= -EADDRNOTAVAIL
;
1095 if ((ax25_dev
= ax25_addr_ax25dev(&addr
->fsa_ax25
.sax25_call
)) == NULL
) {
1096 err
= -EADDRNOTAVAIL
;
1101 if (ax25_dev
!= NULL
)
1102 ax25_fillin_cb(ax25
, ax25_dev
);
1106 sock_reset_flag(sk
, SOCK_ZAPPED
);
1115 * FIXME: nonblock behaviour looks like it may have a bug.
1117 static int __must_check
ax25_connect(struct socket
*sock
,
1118 struct sockaddr
*uaddr
, int addr_len
, int flags
)
1120 struct sock
*sk
= sock
->sk
;
1121 ax25_cb
*ax25
= ax25_sk(sk
), *ax25t
;
1122 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)uaddr
;
1123 ax25_digi
*digi
= NULL
;
1124 int ct
= 0, err
= 0;
1127 * some sanity checks. code further down depends on this
1130 if (addr_len
== sizeof(struct sockaddr_ax25
))
1131 /* support for this will go away in early 2.5.x
1132 * ax25_connect(): uses obsolete socket structure
1135 else if (addr_len
!= sizeof(struct full_sockaddr_ax25
))
1136 /* support for old structure may go away some time
1137 * ax25_connect(): uses old (6 digipeater) socket structure.
1139 if ((addr_len
< sizeof(struct sockaddr_ax25
) + sizeof(ax25_address
) * 6) ||
1140 (addr_len
> sizeof(struct full_sockaddr_ax25
)))
1144 if (fsa
->fsa_ax25
.sax25_family
!= AF_AX25
)
1149 /* deal with restarts */
1150 if (sock
->state
== SS_CONNECTING
) {
1151 switch (sk
->sk_state
) {
1152 case TCP_SYN_SENT
: /* still trying */
1156 case TCP_ESTABLISHED
: /* connection established */
1157 sock
->state
= SS_CONNECTED
;
1160 case TCP_CLOSE
: /* connection refused */
1161 sock
->state
= SS_UNCONNECTED
;
1162 err
= -ECONNREFUSED
;
1167 if (sk
->sk_state
== TCP_ESTABLISHED
&& sk
->sk_type
== SOCK_SEQPACKET
) {
1168 err
= -EISCONN
; /* No reconnect on a seqpacket socket */
1172 sk
->sk_state
= TCP_CLOSE
;
1173 sock
->state
= SS_UNCONNECTED
;
1175 kfree(ax25
->digipeat
);
1176 ax25
->digipeat
= NULL
;
1179 * Handle digi-peaters to be used.
1181 if (addr_len
> sizeof(struct sockaddr_ax25
) &&
1182 fsa
->fsa_ax25
.sax25_ndigis
!= 0) {
1183 /* Valid number of digipeaters ? */
1184 if (fsa
->fsa_ax25
.sax25_ndigis
< 1 || fsa
->fsa_ax25
.sax25_ndigis
> AX25_MAX_DIGIS
) {
1189 if ((digi
= kmalloc(sizeof(ax25_digi
), GFP_KERNEL
)) == NULL
) {
1194 digi
->ndigi
= fsa
->fsa_ax25
.sax25_ndigis
;
1195 digi
->lastrepeat
= -1;
1197 while (ct
< fsa
->fsa_ax25
.sax25_ndigis
) {
1198 if ((fsa
->fsa_digipeater
[ct
].ax25_call
[6] &
1199 AX25_HBIT
) && ax25
->iamdigi
) {
1200 digi
->repeated
[ct
] = 1;
1201 digi
->lastrepeat
= ct
;
1203 digi
->repeated
[ct
] = 0;
1205 digi
->calls
[ct
] = fsa
->fsa_digipeater
[ct
];
1211 * Must bind first - autobinding in this may or may not work. If
1212 * the socket is already bound, check to see if the device has
1213 * been filled in, error if it hasn't.
1215 if (sock_flag(sk
, SOCK_ZAPPED
)) {
1216 /* check if we can remove this feature. It is broken. */
1217 printk(KERN_WARNING
"ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1219 if ((err
= ax25_rt_autobind(ax25
, &fsa
->fsa_ax25
.sax25_call
)) < 0) {
1224 ax25_fillin_cb(ax25
, ax25
->ax25_dev
);
1227 if (ax25
->ax25_dev
== NULL
) {
1229 err
= -EHOSTUNREACH
;
1234 if (sk
->sk_type
== SOCK_SEQPACKET
&&
1235 (ax25t
=ax25_find_cb(&ax25
->source_addr
, &fsa
->fsa_ax25
.sax25_call
, digi
,
1236 ax25
->ax25_dev
->dev
))) {
1238 err
= -EADDRINUSE
; /* Already such a connection */
1243 ax25
->dest_addr
= fsa
->fsa_ax25
.sax25_call
;
1244 ax25
->digipeat
= digi
;
1246 /* First the easy one */
1247 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
1248 sock
->state
= SS_CONNECTED
;
1249 sk
->sk_state
= TCP_ESTABLISHED
;
1253 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1254 sock
->state
= SS_CONNECTING
;
1255 sk
->sk_state
= TCP_SYN_SENT
;
1257 switch (ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
]) {
1258 case AX25_PROTO_STD_SIMPLEX
:
1259 case AX25_PROTO_STD_DUPLEX
:
1260 ax25_std_establish_data_link(ax25
);
1263 #ifdef CONFIG_AX25_DAMA_SLAVE
1264 case AX25_PROTO_DAMA_SLAVE
:
1265 ax25
->modulus
= AX25_MODULUS
;
1266 ax25
->window
= ax25
->ax25_dev
->values
[AX25_VALUES_WINDOW
];
1267 if (ax25
->ax25_dev
->dama
.slave
)
1268 ax25_ds_establish_data_link(ax25
);
1270 ax25_std_establish_data_link(ax25
);
1275 ax25
->state
= AX25_STATE_1
;
1277 ax25_start_heartbeat(ax25
);
1280 if (sk
->sk_state
!= TCP_ESTABLISHED
&& (flags
& O_NONBLOCK
)) {
1285 if (sk
->sk_state
== TCP_SYN_SENT
) {
1289 prepare_to_wait(sk_sleep(sk
), &wait
,
1290 TASK_INTERRUPTIBLE
);
1291 if (sk
->sk_state
!= TCP_SYN_SENT
)
1293 if (!signal_pending(current
)) {
1302 finish_wait(sk_sleep(sk
), &wait
);
1308 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1309 /* Not in ABM, not in WAIT_UA -> failed */
1310 sock
->state
= SS_UNCONNECTED
;
1311 err
= sock_error(sk
); /* Always set at this point */
1315 sock
->state
= SS_CONNECTED
;
1324 static int ax25_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
1326 struct sk_buff
*skb
;
1332 if (sock
->state
!= SS_UNCONNECTED
)
1335 if ((sk
= sock
->sk
) == NULL
)
1339 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
1344 if (sk
->sk_state
!= TCP_LISTEN
) {
1350 * The read queue this time is holding sockets ready to use
1351 * hooked into the SABM we saved
1354 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
1355 skb
= skb_dequeue(&sk
->sk_receive_queue
);
1359 if (flags
& O_NONBLOCK
) {
1363 if (!signal_pending(current
)) {
1372 finish_wait(sk_sleep(sk
), &wait
);
1378 sock_graft(newsk
, newsock
);
1380 /* Now attach up the new socket */
1382 sk
->sk_ack_backlog
--;
1383 newsock
->state
= SS_CONNECTED
;
1391 static int ax25_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
1392 int *uaddr_len
, int peer
)
1394 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)uaddr
;
1395 struct sock
*sk
= sock
->sk
;
1396 unsigned char ndigi
, i
;
1400 memset(fsa
, 0, sizeof(*fsa
));
1405 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1410 fsa
->fsa_ax25
.sax25_family
= AF_AX25
;
1411 fsa
->fsa_ax25
.sax25_call
= ax25
->dest_addr
;
1413 if (ax25
->digipeat
!= NULL
) {
1414 ndigi
= ax25
->digipeat
->ndigi
;
1415 fsa
->fsa_ax25
.sax25_ndigis
= ndigi
;
1416 for (i
= 0; i
< ndigi
; i
++)
1417 fsa
->fsa_digipeater
[i
] =
1418 ax25
->digipeat
->calls
[i
];
1421 fsa
->fsa_ax25
.sax25_family
= AF_AX25
;
1422 fsa
->fsa_ax25
.sax25_call
= ax25
->source_addr
;
1423 fsa
->fsa_ax25
.sax25_ndigis
= 1;
1424 if (ax25
->ax25_dev
!= NULL
) {
1425 memcpy(&fsa
->fsa_digipeater
[0],
1426 ax25
->ax25_dev
->dev
->dev_addr
, AX25_ADDR_LEN
);
1428 fsa
->fsa_digipeater
[0] = null_ax25_address
;
1431 *uaddr_len
= sizeof (struct full_sockaddr_ax25
);
1439 static int ax25_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
1440 struct msghdr
*msg
, size_t len
)
1442 struct sockaddr_ax25
*usax
= (struct sockaddr_ax25
*)msg
->msg_name
;
1443 struct sock
*sk
= sock
->sk
;
1444 struct sockaddr_ax25 sax
;
1445 struct sk_buff
*skb
;
1446 ax25_digi dtmp
, *dp
;
1449 int lv
, err
, addr_len
= msg
->msg_namelen
;
1451 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_EOR
|MSG_CMSG_COMPAT
))
1457 if (sock_flag(sk
, SOCK_ZAPPED
)) {
1458 err
= -EADDRNOTAVAIL
;
1462 if (sk
->sk_shutdown
& SEND_SHUTDOWN
) {
1463 send_sig(SIGPIPE
, current
, 0);
1468 if (ax25
->ax25_dev
== NULL
) {
1473 if (len
> ax25
->ax25_dev
->dev
->mtu
) {
1479 if (usax
->sax25_family
!= AF_AX25
) {
1484 if (addr_len
== sizeof(struct sockaddr_ax25
))
1485 /* ax25_sendmsg(): uses obsolete socket structure */
1487 else if (addr_len
!= sizeof(struct full_sockaddr_ax25
))
1488 /* support for old structure may go away some time
1489 * ax25_sendmsg(): uses old (6 digipeater)
1492 if ((addr_len
< sizeof(struct sockaddr_ax25
) + sizeof(ax25_address
) * 6) ||
1493 (addr_len
> sizeof(struct full_sockaddr_ax25
))) {
1499 if (addr_len
> sizeof(struct sockaddr_ax25
) && usax
->sax25_ndigis
!= 0) {
1501 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)usax
;
1503 /* Valid number of digipeaters ? */
1504 if (usax
->sax25_ndigis
< 1 || usax
->sax25_ndigis
> AX25_MAX_DIGIS
) {
1509 dtmp
.ndigi
= usax
->sax25_ndigis
;
1511 while (ct
< usax
->sax25_ndigis
) {
1512 dtmp
.repeated
[ct
] = 0;
1513 dtmp
.calls
[ct
] = fsa
->fsa_digipeater
[ct
];
1517 dtmp
.lastrepeat
= 0;
1521 if (sk
->sk_type
== SOCK_SEQPACKET
&&
1522 ax25cmp(&ax25
->dest_addr
, &sax
.sax25_call
)) {
1526 if (usax
->sax25_ndigis
== 0)
1532 * FIXME: 1003.1g - if the socket is like this because
1533 * it has become closed (not started closed) and is VC
1534 * we ought to SIGPIPE, EPIPE
1536 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1540 sax
.sax25_family
= AF_AX25
;
1541 sax
.sax25_call
= ax25
->dest_addr
;
1542 dp
= ax25
->digipeat
;
1545 /* Build a packet */
1546 /* Assume the worst case */
1547 size
= len
+ ax25
->ax25_dev
->dev
->hard_header_len
;
1549 skb
= sock_alloc_send_skb(sk
, size
, msg
->msg_flags
&MSG_DONTWAIT
, &err
);
1553 skb_reserve(skb
, size
- len
);
1555 /* User data follows immediately after the AX.25 data */
1556 if (memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
)) {
1562 skb_reset_network_header(skb
);
1564 /* Add the PID if one is not supplied by the user in the skb */
1566 *skb_push(skb
, 1) = sk
->sk_protocol
;
1568 if (sk
->sk_type
== SOCK_SEQPACKET
) {
1569 /* Connected mode sockets go via the LAPB machine */
1570 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1576 /* Shove it onto the queue and kick */
1577 ax25_output(ax25
, ax25
->paclen
, skb
);
1583 skb_push(skb
, 1 + ax25_addr_size(dp
));
1585 /* Building AX.25 Header */
1587 /* Build an AX.25 header */
1588 lv
= ax25_addr_build(skb
->data
, &ax25
->source_addr
, &sax
.sax25_call
,
1589 dp
, AX25_COMMAND
, AX25_MODULUS
);
1591 skb_set_transport_header(skb
, lv
);
1593 *skb_transport_header(skb
) = AX25_UI
;
1595 /* Datagram frames go straight out of the door as UI */
1596 ax25_queue_xmit(skb
, ax25
->ax25_dev
->dev
);
1606 static int ax25_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
1607 struct msghdr
*msg
, size_t size
, int flags
)
1609 struct sock
*sk
= sock
->sk
;
1610 struct sk_buff
*skb
;
1616 * This works for seqpacket too. The receiver has ordered the
1617 * queue for us! We do one quick check first though
1619 if (sk
->sk_type
== SOCK_SEQPACKET
&& sk
->sk_state
!= TCP_ESTABLISHED
) {
1624 /* Now we can treat all alike */
1625 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
1626 flags
& MSG_DONTWAIT
, &err
);
1630 if (!ax25_sk(sk
)->pidincl
)
1631 skb_pull(skb
, 1); /* Remove PID */
1633 skb_reset_transport_header(skb
);
1636 if (copied
> size
) {
1638 msg
->msg_flags
|= MSG_TRUNC
;
1641 skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
1643 if (msg
->msg_namelen
!= 0) {
1644 struct sockaddr_ax25
*sax
= (struct sockaddr_ax25
*)msg
->msg_name
;
1647 const unsigned char *mac
= skb_mac_header(skb
);
1649 ax25_addr_parse(mac
+ 1, skb
->data
- mac
- 1, &src
, NULL
,
1651 sax
->sax25_family
= AF_AX25
;
1652 /* We set this correctly, even though we may not let the
1653 application know the digi calls further down (because it
1654 did NOT ask to know them). This could get political... **/
1655 sax
->sax25_ndigis
= digi
.ndigi
;
1656 sax
->sax25_call
= src
;
1658 if (sax
->sax25_ndigis
!= 0) {
1660 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)sax
;
1662 for (ct
= 0; ct
< digi
.ndigi
; ct
++)
1663 fsa
->fsa_digipeater
[ct
] = digi
.calls
[ct
];
1665 msg
->msg_namelen
= sizeof(struct full_sockaddr_ax25
);
1668 skb_free_datagram(sk
, skb
);
1677 static int ax25_shutdown(struct socket
*sk
, int how
)
1679 /* FIXME - generate DM and RNR states */
1683 static int ax25_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1685 struct sock
*sk
= sock
->sk
;
1686 void __user
*argp
= (void __user
*)arg
;
1694 amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
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
);
1716 res
= sock_get_timestampns(sk
, argp
);
1719 case SIOCAX25ADDUID
: /* Add a uid to the uid/call map table */
1720 case SIOCAX25DELUID
: /* Delete a uid from the uid/call map table */
1721 case SIOCAX25GETUID
: {
1722 struct sockaddr_ax25 sax25
;
1723 if (copy_from_user(&sax25
, argp
, sizeof(sax25
))) {
1727 res
= ax25_uid_ioctl(cmd
, &sax25
);
1731 case SIOCAX25NOUID
: { /* Set the default policy (default/bar) */
1733 if (!capable(CAP_NET_ADMIN
)) {
1737 if (get_user(amount
, (long __user
*)argp
)) {
1741 if (amount
> AX25_NOUID_BLOCK
) {
1745 ax25_uid_policy
= amount
;
1753 if (!capable(CAP_NET_ADMIN
)) {
1757 res
= ax25_rt_ioctl(cmd
, argp
);
1760 case SIOCAX25CTLCON
:
1761 if (!capable(CAP_NET_ADMIN
)) {
1765 res
= ax25_ctl_ioctl(cmd
, argp
);
1768 case SIOCAX25GETINFO
:
1769 case SIOCAX25GETINFOOLD
: {
1770 ax25_cb
*ax25
= ax25_sk(sk
);
1771 struct ax25_info_struct ax25_info
;
1773 ax25_info
.t1
= ax25
->t1
/ HZ
;
1774 ax25_info
.t2
= ax25
->t2
/ HZ
;
1775 ax25_info
.t3
= ax25
->t3
/ HZ
;
1776 ax25_info
.idle
= ax25
->idle
/ (60 * HZ
);
1777 ax25_info
.n2
= ax25
->n2
;
1778 ax25_info
.t1timer
= ax25_display_timer(&ax25
->t1timer
) / HZ
;
1779 ax25_info
.t2timer
= ax25_display_timer(&ax25
->t2timer
) / HZ
;
1780 ax25_info
.t3timer
= ax25_display_timer(&ax25
->t3timer
) / HZ
;
1781 ax25_info
.idletimer
= ax25_display_timer(&ax25
->idletimer
) / (60 * HZ
);
1782 ax25_info
.n2count
= ax25
->n2count
;
1783 ax25_info
.state
= ax25
->state
;
1784 ax25_info
.rcv_q
= sk_rmem_alloc_get(sk
);
1785 ax25_info
.snd_q
= sk_wmem_alloc_get(sk
);
1786 ax25_info
.vs
= ax25
->vs
;
1787 ax25_info
.vr
= ax25
->vr
;
1788 ax25_info
.va
= ax25
->va
;
1789 ax25_info
.vs_max
= ax25
->vs
; /* reserved */
1790 ax25_info
.paclen
= ax25
->paclen
;
1791 ax25_info
.window
= ax25
->window
;
1793 /* old structure? */
1794 if (cmd
== SIOCAX25GETINFOOLD
) {
1795 static int warned
= 0;
1797 printk(KERN_INFO
"%s uses old SIOCAX25GETINFO\n",
1802 if (copy_to_user(argp
, &ax25_info
, sizeof(struct ax25_info_struct_deprecated
))) {
1807 if (copy_to_user(argp
, &ax25_info
, sizeof(struct ax25_info_struct
))) {
1816 case SIOCAX25ADDFWD
:
1817 case SIOCAX25DELFWD
: {
1818 struct ax25_fwd_struct ax25_fwd
;
1819 if (!capable(CAP_NET_ADMIN
)) {
1823 if (copy_from_user(&ax25_fwd
, argp
, sizeof(ax25_fwd
))) {
1827 res
= ax25_fwd_ioctl(cmd
, &ax25_fwd
);
1833 case SIOCGIFDSTADDR
:
1834 case SIOCSIFDSTADDR
:
1835 case SIOCGIFBRDADDR
:
1836 case SIOCSIFBRDADDR
:
1837 case SIOCGIFNETMASK
:
1838 case SIOCSIFNETMASK
:
1853 #ifdef CONFIG_PROC_FS
1855 static void *ax25_info_start(struct seq_file
*seq
, loff_t
*pos
)
1856 __acquires(ax25_list_lock
)
1858 spin_lock_bh(&ax25_list_lock
);
1859 return seq_hlist_start(&ax25_list
, *pos
);
1862 static void *ax25_info_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1864 return seq_hlist_next(v
, &ax25_list
, pos
);
1867 static void ax25_info_stop(struct seq_file
*seq
, void *v
)
1868 __releases(ax25_list_lock
)
1870 spin_unlock_bh(&ax25_list_lock
);
1873 static int ax25_info_show(struct seq_file
*seq
, void *v
)
1875 ax25_cb
*ax25
= hlist_entry(v
, struct ax25_cb
, ax25_node
);
1882 * 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
1885 seq_printf(seq
, "%8.8lx %s %s%s ",
1887 ax25
->ax25_dev
== NULL
? "???" : ax25
->ax25_dev
->dev
->name
,
1888 ax2asc(buf
, &ax25
->source_addr
),
1889 ax25
->iamdigi
? "*":"");
1890 seq_printf(seq
, "%s", ax2asc(buf
, &ax25
->dest_addr
));
1892 for (k
=0; (ax25
->digipeat
!= NULL
) && (k
< ax25
->digipeat
->ndigi
); k
++) {
1893 seq_printf(seq
, ",%s%s",
1894 ax2asc(buf
, &ax25
->digipeat
->calls
[k
]),
1895 ax25
->digipeat
->repeated
[k
]? "*":"");
1898 seq_printf(seq
, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1900 ax25
->vs
, ax25
->vr
, ax25
->va
,
1901 ax25_display_timer(&ax25
->t1timer
) / HZ
, ax25
->t1
/ HZ
,
1902 ax25_display_timer(&ax25
->t2timer
) / HZ
, ax25
->t2
/ HZ
,
1903 ax25_display_timer(&ax25
->t3timer
) / HZ
, ax25
->t3
/ HZ
,
1904 ax25_display_timer(&ax25
->idletimer
) / (60 * HZ
),
1905 ax25
->idle
/ (60 * HZ
),
1906 ax25
->n2count
, ax25
->n2
,
1911 if (ax25
->sk
!= NULL
) {
1912 seq_printf(seq
, " %d %d %lu\n",
1913 sk_wmem_alloc_get(ax25
->sk
),
1914 sk_rmem_alloc_get(ax25
->sk
),
1915 sock_i_ino(ax25
->sk
));
1917 seq_puts(seq
, " * * *\n");
1922 static const struct seq_operations ax25_info_seqops
= {
1923 .start
= ax25_info_start
,
1924 .next
= ax25_info_next
,
1925 .stop
= ax25_info_stop
,
1926 .show
= ax25_info_show
,
1929 static int ax25_info_open(struct inode
*inode
, struct file
*file
)
1931 return seq_open(file
, &ax25_info_seqops
);
1934 static const struct file_operations ax25_info_fops
= {
1935 .owner
= THIS_MODULE
,
1936 .open
= ax25_info_open
,
1938 .llseek
= seq_lseek
,
1939 .release
= seq_release
,
1944 static const struct net_proto_family ax25_family_ops
= {
1946 .create
= ax25_create
,
1947 .owner
= THIS_MODULE
,
1950 static const struct proto_ops ax25_proto_ops
= {
1952 .owner
= THIS_MODULE
,
1953 .release
= ax25_release
,
1955 .connect
= ax25_connect
,
1956 .socketpair
= sock_no_socketpair
,
1957 .accept
= ax25_accept
,
1958 .getname
= ax25_getname
,
1959 .poll
= datagram_poll
,
1960 .ioctl
= ax25_ioctl
,
1961 .listen
= ax25_listen
,
1962 .shutdown
= ax25_shutdown
,
1963 .setsockopt
= ax25_setsockopt
,
1964 .getsockopt
= ax25_getsockopt
,
1965 .sendmsg
= ax25_sendmsg
,
1966 .recvmsg
= ax25_recvmsg
,
1967 .mmap
= sock_no_mmap
,
1968 .sendpage
= sock_no_sendpage
,
1972 * Called by socket.c on kernel start up
1974 static struct packet_type ax25_packet_type __read_mostly
= {
1975 .type
= cpu_to_be16(ETH_P_AX25
),
1976 .func
= ax25_kiss_rcv
,
1979 static struct notifier_block ax25_dev_notifier
= {
1980 .notifier_call
=ax25_device_event
,
1983 static int __init
ax25_init(void)
1985 int rc
= proto_register(&ax25_proto
, 0);
1990 sock_register(&ax25_family_ops
);
1991 dev_add_pack(&ax25_packet_type
);
1992 register_netdevice_notifier(&ax25_dev_notifier
);
1994 proc_net_fops_create(&init_net
, "ax25_route", S_IRUGO
, &ax25_route_fops
);
1995 proc_net_fops_create(&init_net
, "ax25", S_IRUGO
, &ax25_info_fops
);
1996 proc_net_fops_create(&init_net
, "ax25_calls", S_IRUGO
, &ax25_uid_fops
);
2000 module_init(ax25_init
);
2003 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2004 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2005 MODULE_LICENSE("GPL");
2006 MODULE_ALIAS_NETPROTO(PF_AX25
);
2008 static void __exit
ax25_exit(void)
2010 proc_net_remove(&init_net
, "ax25_route");
2011 proc_net_remove(&init_net
, "ax25");
2012 proc_net_remove(&init_net
, "ax25_calls");
2014 unregister_netdevice_notifier(&ax25_dev_notifier
);
2016 dev_remove_pack(&ax25_packet_type
);
2018 sock_unregister(PF_AX25
);
2019 proto_unregister(&ax25_proto
);
2025 module_exit(ax25_exit
);