2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
7 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
8 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
9 * Copyright (C) Darryl Miles G7LED (dlm@g7led.demon.co.uk)
10 * Copyright (C) Steven Whitehouse GW7RRM (stevew@acm.org)
11 * Copyright (C) Joerg Reuter DL1BKE (jreuter@yaina.de)
12 * Copyright (C) Hans-Joachim Hetscher DD8NE (dd8ne@bnv-bamberg.de)
13 * Copyright (C) Hans Alblas PE1AYX (hans@esrac.ele.tue.nl)
14 * Copyright (C) Frederic Rible F1OAT (frible@teaser.fr)
16 #include <linux/capability.h>
17 #include <linux/module.h>
18 #include <linux/errno.h>
19 #include <linux/types.h>
20 #include <linux/socket.h>
22 #include <linux/kernel.h>
23 #include <linux/sched/signal.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <linux/slab.h>
30 #include <linux/inet.h>
31 #include <linux/netdevice.h>
32 #include <linux/if_arp.h>
33 #include <linux/skbuff.h>
35 #include <linux/uaccess.h>
36 #include <linux/fcntl.h>
37 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
39 #include <linux/interrupt.h>
40 #include <linux/notifier.h>
41 #include <linux/proc_fs.h>
42 #include <linux/stat.h>
43 #include <linux/sysctl.h>
44 #include <linux/init.h>
45 #include <linux/spinlock.h>
46 #include <net/net_namespace.h>
47 #include <net/tcp_states.h>
53 HLIST_HEAD(ax25_list
);
54 DEFINE_SPINLOCK(ax25_list_lock
);
56 static const struct proto_ops ax25_proto_ops
;
58 static void ax25_free_sock(struct sock
*sk
)
60 ax25_cb_put(sk_to_ax25(sk
));
64 * Socket removal during an interrupt is now safe.
66 static void ax25_cb_del(ax25_cb
*ax25
)
68 if (!hlist_unhashed(&ax25
->ax25_node
)) {
69 spin_lock_bh(&ax25_list_lock
);
70 hlist_del_init(&ax25
->ax25_node
);
71 spin_unlock_bh(&ax25_list_lock
);
77 * Kill all bound sockets on a dropped device.
79 static void ax25_kill_by_device(struct net_device
*dev
)
84 if ((ax25_dev
= ax25_dev_ax25dev(dev
)) == NULL
)
87 spin_lock_bh(&ax25_list_lock
);
89 ax25_for_each(s
, &ax25_list
) {
90 if (s
->ax25_dev
== ax25_dev
) {
92 spin_unlock_bh(&ax25_list_lock
);
93 ax25_disconnect(s
, ENETUNREACH
);
94 spin_lock_bh(&ax25_list_lock
);
96 /* The entry could have been deleted from the
97 * list meanwhile and thus the next pointer is
98 * no longer valid. Play it safe and restart
99 * the scan. Forward progress is ensured
100 * because we set s->ax25_dev to NULL and we
101 * are never passed a NULL 'dev' argument.
106 spin_unlock_bh(&ax25_list_lock
);
110 * Handle device status changes.
112 static int ax25_device_event(struct notifier_block
*this, unsigned long event
,
115 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
117 if (!net_eq(dev_net(dev
), &init_net
))
120 /* Reject non AX.25 devices */
121 if (dev
->type
!= ARPHRD_AX25
)
126 ax25_dev_device_up(dev
);
129 ax25_kill_by_device(dev
);
130 ax25_rt_device_down(dev
);
131 ax25_dev_device_down(dev
);
141 * Add a socket to the bound sockets list.
143 void ax25_cb_add(ax25_cb
*ax25
)
145 spin_lock_bh(&ax25_list_lock
);
147 hlist_add_head(&ax25
->ax25_node
, &ax25_list
);
148 spin_unlock_bh(&ax25_list_lock
);
152 * Find a socket that wants to accept the SABM we have just
155 struct sock
*ax25_find_listener(ax25_address
*addr
, int digi
,
156 struct net_device
*dev
, int type
)
160 spin_lock(&ax25_list_lock
);
161 ax25_for_each(s
, &ax25_list
) {
162 if ((s
->iamdigi
&& !digi
) || (!s
->iamdigi
&& digi
))
164 if (s
->sk
&& !ax25cmp(&s
->source_addr
, addr
) &&
165 s
->sk
->sk_type
== type
&& s
->sk
->sk_state
== TCP_LISTEN
) {
166 /* If device is null we match any device */
167 if (s
->ax25_dev
== NULL
|| s
->ax25_dev
->dev
== dev
) {
169 spin_unlock(&ax25_list_lock
);
174 spin_unlock(&ax25_list_lock
);
180 * Find an AX.25 socket given both ends.
182 struct sock
*ax25_get_socket(ax25_address
*my_addr
, ax25_address
*dest_addr
,
185 struct sock
*sk
= NULL
;
188 spin_lock(&ax25_list_lock
);
189 ax25_for_each(s
, &ax25_list
) {
190 if (s
->sk
&& !ax25cmp(&s
->source_addr
, my_addr
) &&
191 !ax25cmp(&s
->dest_addr
, dest_addr
) &&
192 s
->sk
->sk_type
== type
) {
199 spin_unlock(&ax25_list_lock
);
205 * Find an AX.25 control block given both ends. It will only pick up
206 * floating AX.25 control blocks or non Raw socket bound control blocks.
208 ax25_cb
*ax25_find_cb(ax25_address
*src_addr
, ax25_address
*dest_addr
,
209 ax25_digi
*digi
, struct net_device
*dev
)
213 spin_lock_bh(&ax25_list_lock
);
214 ax25_for_each(s
, &ax25_list
) {
215 if (s
->sk
&& s
->sk
->sk_type
!= SOCK_SEQPACKET
)
217 if (s
->ax25_dev
== NULL
)
219 if (ax25cmp(&s
->source_addr
, src_addr
) == 0 && ax25cmp(&s
->dest_addr
, dest_addr
) == 0 && s
->ax25_dev
->dev
== dev
) {
220 if (digi
!= NULL
&& digi
->ndigi
!= 0) {
221 if (s
->digipeat
== NULL
)
223 if (ax25digicmp(s
->digipeat
, digi
) != 0)
226 if (s
->digipeat
!= NULL
&& s
->digipeat
->ndigi
!= 0)
230 spin_unlock_bh(&ax25_list_lock
);
235 spin_unlock_bh(&ax25_list_lock
);
240 EXPORT_SYMBOL(ax25_find_cb
);
242 void ax25_send_to_raw(ax25_address
*addr
, struct sk_buff
*skb
, int proto
)
245 struct sk_buff
*copy
;
247 spin_lock(&ax25_list_lock
);
248 ax25_for_each(s
, &ax25_list
) {
249 if (s
->sk
!= NULL
&& ax25cmp(&s
->source_addr
, addr
) == 0 &&
250 s
->sk
->sk_type
== SOCK_RAW
&&
251 s
->sk
->sk_protocol
== proto
&&
252 s
->ax25_dev
->dev
== skb
->dev
&&
253 atomic_read(&s
->sk
->sk_rmem_alloc
) <= s
->sk
->sk_rcvbuf
) {
254 if ((copy
= skb_clone(skb
, GFP_ATOMIC
)) == NULL
)
256 if (sock_queue_rcv_skb(s
->sk
, copy
) != 0)
260 spin_unlock(&ax25_list_lock
);
266 void ax25_destroy_socket(ax25_cb
*);
269 * Handler for deferred kills.
271 static void ax25_destroy_timer(struct timer_list
*t
)
273 ax25_cb
*ax25
= from_timer(ax25
, t
, dtimer
);
280 ax25_destroy_socket(ax25
);
286 * This is called from user mode and the timers. Thus it protects itself
287 * against interrupt users but doesn't worry about being called during
288 * work. Once it is removed from the queue no interrupt or bottom half
289 * will touch it and we are (fairly 8-) ) safe.
291 void ax25_destroy_socket(ax25_cb
*ax25
)
297 ax25_stop_heartbeat(ax25
);
298 ax25_stop_t1timer(ax25
);
299 ax25_stop_t2timer(ax25
);
300 ax25_stop_t3timer(ax25
);
301 ax25_stop_idletimer(ax25
);
303 ax25_clear_queues(ax25
); /* Flush the queues */
305 if (ax25
->sk
!= NULL
) {
306 while ((skb
= skb_dequeue(&ax25
->sk
->sk_receive_queue
)) != NULL
) {
307 if (skb
->sk
!= ax25
->sk
) {
308 /* A pending connection */
309 ax25_cb
*sax25
= sk_to_ax25(skb
->sk
);
311 /* Queue the unaccepted socket for death */
312 sock_orphan(skb
->sk
);
314 /* 9A4GL: hack to release unaccepted sockets */
315 skb
->sk
->sk_state
= TCP_LISTEN
;
317 ax25_start_heartbeat(sax25
);
318 sax25
->state
= AX25_STATE_0
;
323 skb_queue_purge(&ax25
->sk
->sk_write_queue
);
326 if (ax25
->sk
!= NULL
) {
327 if (sk_has_allocations(ax25
->sk
)) {
328 /* Defer: outstanding buffers */
329 timer_setup(&ax25
->dtimer
, ax25_destroy_timer
, 0);
330 ax25
->dtimer
.expires
= jiffies
+ 2 * HZ
;
331 add_timer(&ax25
->dtimer
);
333 struct sock
*sk
=ax25
->sk
;
343 * dl1bke 960311: set parameters for existing AX.25 connections,
344 * includes a KILL command to abort any connection.
345 * VERY useful for debugging ;-)
347 static int ax25_ctl_ioctl(const unsigned int cmd
, void __user
*arg
)
349 struct ax25_ctl_struct ax25_ctl
;
356 if (copy_from_user(&ax25_ctl
, arg
, sizeof(ax25_ctl
)))
359 if ((ax25_dev
= ax25_addr_ax25dev(&ax25_ctl
.port_addr
)) == NULL
)
362 if (ax25_ctl
.digi_count
> AX25_MAX_DIGIS
)
365 if (ax25_ctl
.arg
> ULONG_MAX
/ HZ
&& ax25_ctl
.cmd
!= AX25_KILL
)
368 digi
.ndigi
= ax25_ctl
.digi_count
;
369 for (k
= 0; k
< digi
.ndigi
; k
++)
370 digi
.calls
[k
] = ax25_ctl
.digi_addr
[k
];
372 if ((ax25
= ax25_find_cb(&ax25_ctl
.source_addr
, &ax25_ctl
.dest_addr
, &digi
, ax25_dev
->dev
)) == NULL
)
375 switch (ax25_ctl
.cmd
) {
377 ax25_send_control(ax25
, AX25_DISC
, AX25_POLLON
, AX25_COMMAND
);
378 #ifdef CONFIG_AX25_DAMA_SLAVE
379 if (ax25_dev
->dama
.slave
&& ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
] == AX25_PROTO_DAMA_SLAVE
)
382 ax25_disconnect(ax25
, ENETRESET
);
386 if (ax25
->modulus
== AX25_MODULUS
) {
387 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> 7)
390 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> 63)
393 ax25
->window
= ax25_ctl
.arg
;
397 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> ULONG_MAX
/ HZ
)
399 ax25
->rtt
= (ax25_ctl
.arg
* HZ
) / 2;
400 ax25
->t1
= ax25_ctl
.arg
* HZ
;
404 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> ULONG_MAX
/ HZ
)
406 ax25
->t2
= ax25_ctl
.arg
* HZ
;
410 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> 31)
413 ax25
->n2
= ax25_ctl
.arg
;
417 if (ax25_ctl
.arg
> ULONG_MAX
/ HZ
)
419 ax25
->t3
= ax25_ctl
.arg
* HZ
;
423 if (ax25_ctl
.arg
> ULONG_MAX
/ (60 * HZ
))
426 ax25
->idle
= ax25_ctl
.arg
* 60 * HZ
;
430 if (ax25_ctl
.arg
< 16 || ax25_ctl
.arg
> 65535)
432 ax25
->paclen
= ax25_ctl
.arg
;
448 static void ax25_fillin_cb_from_dev(ax25_cb
*ax25
, ax25_dev
*ax25_dev
)
450 ax25
->rtt
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T1
]) / 2;
451 ax25
->t1
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T1
]);
452 ax25
->t2
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T2
]);
453 ax25
->t3
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T3
]);
454 ax25
->n2
= ax25_dev
->values
[AX25_VALUES_N2
];
455 ax25
->paclen
= ax25_dev
->values
[AX25_VALUES_PACLEN
];
456 ax25
->idle
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_IDLE
]);
457 ax25
->backoff
= ax25_dev
->values
[AX25_VALUES_BACKOFF
];
459 if (ax25_dev
->values
[AX25_VALUES_AXDEFMODE
]) {
460 ax25
->modulus
= AX25_EMODULUS
;
461 ax25
->window
= ax25_dev
->values
[AX25_VALUES_EWINDOW
];
463 ax25
->modulus
= AX25_MODULUS
;
464 ax25
->window
= ax25_dev
->values
[AX25_VALUES_WINDOW
];
469 * Fill in a created AX.25 created control block with the default
470 * values for a particular device.
472 void ax25_fillin_cb(ax25_cb
*ax25
, ax25_dev
*ax25_dev
)
474 ax25
->ax25_dev
= ax25_dev
;
476 if (ax25
->ax25_dev
!= NULL
) {
477 ax25_fillin_cb_from_dev(ax25
, ax25_dev
);
482 * No device, use kernel / AX.25 spec default values
484 ax25
->rtt
= msecs_to_jiffies(AX25_DEF_T1
) / 2;
485 ax25
->t1
= msecs_to_jiffies(AX25_DEF_T1
);
486 ax25
->t2
= msecs_to_jiffies(AX25_DEF_T2
);
487 ax25
->t3
= msecs_to_jiffies(AX25_DEF_T3
);
488 ax25
->n2
= AX25_DEF_N2
;
489 ax25
->paclen
= AX25_DEF_PACLEN
;
490 ax25
->idle
= msecs_to_jiffies(AX25_DEF_IDLE
);
491 ax25
->backoff
= AX25_DEF_BACKOFF
;
493 if (AX25_DEF_AXDEFMODE
) {
494 ax25
->modulus
= AX25_EMODULUS
;
495 ax25
->window
= AX25_DEF_EWINDOW
;
497 ax25
->modulus
= AX25_MODULUS
;
498 ax25
->window
= AX25_DEF_WINDOW
;
503 * Create an empty AX.25 control block.
505 ax25_cb
*ax25_create_cb(void)
509 if ((ax25
= kzalloc(sizeof(*ax25
), GFP_ATOMIC
)) == NULL
)
512 refcount_set(&ax25
->refcount
, 1);
514 skb_queue_head_init(&ax25
->write_queue
);
515 skb_queue_head_init(&ax25
->frag_queue
);
516 skb_queue_head_init(&ax25
->ack_queue
);
517 skb_queue_head_init(&ax25
->reseq_queue
);
519 ax25_setup_timers(ax25
);
521 ax25_fillin_cb(ax25
, NULL
);
523 ax25
->state
= AX25_STATE_0
;
529 * Handling for system calls applied via the various interfaces to an
533 static int ax25_setsockopt(struct socket
*sock
, int level
, int optname
,
534 char __user
*optval
, unsigned int optlen
)
536 struct sock
*sk
= sock
->sk
;
538 struct net_device
*dev
;
539 char devname
[IFNAMSIZ
];
543 if (level
!= SOL_AX25
)
546 if (optlen
< sizeof(unsigned int))
549 if (get_user(opt
, (unsigned int __user
*)optval
))
553 ax25
= sk_to_ax25(sk
);
557 if (ax25
->modulus
== AX25_MODULUS
) {
558 if (opt
< 1 || opt
> 7) {
563 if (opt
< 1 || opt
> 63) {
572 if (opt
< 1 || opt
> ULONG_MAX
/ HZ
) {
576 ax25
->rtt
= (opt
* HZ
) >> 1;
581 if (opt
< 1 || opt
> ULONG_MAX
/ HZ
) {
589 if (opt
< 1 || opt
> 31) {
597 if (opt
< 1 || opt
> ULONG_MAX
/ HZ
) {
605 if (opt
> ULONG_MAX
/ (60 * HZ
)) {
609 ax25
->idle
= opt
* 60 * HZ
;
621 ax25
->modulus
= opt
? AX25_EMODULUS
: AX25_MODULUS
;
625 ax25
->pidincl
= opt
? 1 : 0;
629 ax25
->iamdigi
= opt
? 1 : 0;
633 if (opt
< 16 || opt
> 65535) {
640 case SO_BINDTODEVICE
:
641 if (optlen
> IFNAMSIZ
)
644 if (copy_from_user(devname
, optval
, optlen
)) {
649 if (sk
->sk_type
== SOCK_SEQPACKET
&&
650 (sock
->state
!= SS_UNCONNECTED
||
651 sk
->sk_state
== TCP_LISTEN
)) {
652 res
= -EADDRNOTAVAIL
;
656 dev
= dev_get_by_name(&init_net
, devname
);
662 ax25
->ax25_dev
= ax25_dev_ax25dev(dev
);
663 ax25_fillin_cb(ax25
, ax25
->ax25_dev
);
675 static int ax25_getsockopt(struct socket
*sock
, int level
, int optname
,
676 char __user
*optval
, int __user
*optlen
)
678 struct sock
*sk
= sock
->sk
;
680 struct ax25_dev
*ax25_dev
;
681 char devname
[IFNAMSIZ
];
686 if (level
!= SOL_AX25
)
689 if (get_user(maxlen
, optlen
))
695 valptr
= (void *) &val
;
696 length
= min_t(unsigned int, maxlen
, sizeof(int));
699 ax25
= sk_to_ax25(sk
);
723 val
= ax25
->idle
/ (60 * HZ
);
731 val
= (ax25
->modulus
== AX25_EMODULUS
);
746 case SO_BINDTODEVICE
:
747 ax25_dev
= ax25
->ax25_dev
;
749 if (ax25_dev
!= NULL
&& ax25_dev
->dev
!= NULL
) {
750 strlcpy(devname
, ax25_dev
->dev
->name
, sizeof(devname
));
751 length
= strlen(devname
) + 1;
757 valptr
= (void *) devname
;
766 if (put_user(length
, optlen
))
769 return copy_to_user(optval
, valptr
, length
) ? -EFAULT
: 0;
772 static int ax25_listen(struct socket
*sock
, int backlog
)
774 struct sock
*sk
= sock
->sk
;
778 if (sk
->sk_type
== SOCK_SEQPACKET
&& sk
->sk_state
!= TCP_LISTEN
) {
779 sk
->sk_max_ack_backlog
= backlog
;
780 sk
->sk_state
= TCP_LISTEN
;
792 * XXX: when creating ax25_sock we should update the .obj_size setting
795 static struct proto ax25_proto
= {
797 .owner
= THIS_MODULE
,
798 .obj_size
= sizeof(struct ax25_sock
),
801 static int ax25_create(struct net
*net
, struct socket
*sock
, int protocol
,
807 if (protocol
< 0 || protocol
> SK_PROTOCOL_MAX
)
810 if (!net_eq(net
, &init_net
))
811 return -EAFNOSUPPORT
;
813 switch (sock
->type
) {
815 if (protocol
== 0 || protocol
== PF_AX25
)
816 protocol
= AX25_P_TEXT
;
822 case PF_AX25
: /* For CLX */
823 protocol
= AX25_P_TEXT
;
836 return -ESOCKTNOSUPPORT
;
837 #ifdef CONFIG_NETROM_MODULE
839 if (ax25_protocol_is_registered(AX25_P_NETROM
))
840 return -ESOCKTNOSUPPORT
;
843 #ifdef CONFIG_ROSE_MODULE
845 if (ax25_protocol_is_registered(AX25_P_ROSE
))
846 return -ESOCKTNOSUPPORT
;
856 return -ESOCKTNOSUPPORT
;
859 sk
= sk_alloc(net
, PF_AX25
, GFP_ATOMIC
, &ax25_proto
, kern
);
863 ax25
= ax25_sk(sk
)->cb
= ax25_create_cb();
869 sock_init_data(sock
, sk
);
871 sk
->sk_destruct
= ax25_free_sock
;
872 sock
->ops
= &ax25_proto_ops
;
873 sk
->sk_protocol
= protocol
;
880 struct sock
*ax25_make_new(struct sock
*osk
, struct ax25_dev
*ax25_dev
)
883 ax25_cb
*ax25
, *oax25
;
885 sk
= sk_alloc(sock_net(osk
), PF_AX25
, GFP_ATOMIC
, osk
->sk_prot
, 0);
889 if ((ax25
= ax25_create_cb()) == NULL
) {
894 switch (osk
->sk_type
) {
905 sock_init_data(NULL
, sk
);
907 sk
->sk_type
= osk
->sk_type
;
908 sk
->sk_priority
= osk
->sk_priority
;
909 sk
->sk_protocol
= osk
->sk_protocol
;
910 sk
->sk_rcvbuf
= osk
->sk_rcvbuf
;
911 sk
->sk_sndbuf
= osk
->sk_sndbuf
;
912 sk
->sk_state
= TCP_ESTABLISHED
;
913 sock_copy_flags(sk
, osk
);
915 oax25
= sk_to_ax25(osk
);
917 ax25
->modulus
= oax25
->modulus
;
918 ax25
->backoff
= oax25
->backoff
;
919 ax25
->pidincl
= oax25
->pidincl
;
920 ax25
->iamdigi
= oax25
->iamdigi
;
921 ax25
->rtt
= oax25
->rtt
;
922 ax25
->t1
= oax25
->t1
;
923 ax25
->t2
= oax25
->t2
;
924 ax25
->t3
= oax25
->t3
;
925 ax25
->n2
= oax25
->n2
;
926 ax25
->idle
= oax25
->idle
;
927 ax25
->paclen
= oax25
->paclen
;
928 ax25
->window
= oax25
->window
;
930 ax25
->ax25_dev
= ax25_dev
;
931 ax25
->source_addr
= oax25
->source_addr
;
933 if (oax25
->digipeat
!= NULL
) {
934 ax25
->digipeat
= kmemdup(oax25
->digipeat
, sizeof(ax25_digi
),
936 if (ax25
->digipeat
== NULL
) {
943 ax25_sk(sk
)->cb
= ax25
;
944 sk
->sk_destruct
= ax25_free_sock
;
950 static int ax25_release(struct socket
*sock
)
952 struct sock
*sk
= sock
->sk
;
961 ax25
= sk_to_ax25(sk
);
963 if (sk
->sk_type
== SOCK_SEQPACKET
) {
964 switch (ax25
->state
) {
967 ax25_disconnect(ax25
, 0);
969 ax25_destroy_socket(ax25
);
974 ax25_send_control(ax25
, AX25_DISC
, AX25_POLLON
, AX25_COMMAND
);
976 ax25_disconnect(ax25
, 0);
978 if (!sock_flag(ax25
->sk
, SOCK_DESTROY
))
979 ax25_destroy_socket(ax25
);
984 ax25_clear_queues(ax25
);
987 switch (ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
]) {
988 case AX25_PROTO_STD_SIMPLEX
:
989 case AX25_PROTO_STD_DUPLEX
:
990 ax25_send_control(ax25
,
994 ax25_stop_t2timer(ax25
);
995 ax25_stop_t3timer(ax25
);
996 ax25_stop_idletimer(ax25
);
998 #ifdef CONFIG_AX25_DAMA_SLAVE
999 case AX25_PROTO_DAMA_SLAVE
:
1000 ax25_stop_t3timer(ax25
);
1001 ax25_stop_idletimer(ax25
);
1005 ax25_calculate_t1(ax25
);
1006 ax25_start_t1timer(ax25
);
1007 ax25
->state
= AX25_STATE_2
;
1008 sk
->sk_state
= TCP_CLOSE
;
1009 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
1010 sk
->sk_state_change(sk
);
1011 sock_set_flag(sk
, SOCK_DESTROY
);
1018 sk
->sk_state
= TCP_CLOSE
;
1019 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
1020 sk
->sk_state_change(sk
);
1021 ax25_destroy_socket(ax25
);
1032 * We support a funny extension here so you can (as root) give any callsign
1033 * digipeated via a local address as source. This hack is obsolete now
1034 * that we've implemented support for SO_BINDTODEVICE. It is however small
1035 * and trivially backward compatible.
1037 static int ax25_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
1039 struct sock
*sk
= sock
->sk
;
1040 struct full_sockaddr_ax25
*addr
= (struct full_sockaddr_ax25
*)uaddr
;
1041 ax25_dev
*ax25_dev
= NULL
;
1042 ax25_uid_assoc
*user
;
1047 if (addr_len
!= sizeof(struct sockaddr_ax25
) &&
1048 addr_len
!= sizeof(struct full_sockaddr_ax25
))
1049 /* support for old structure may go away some time
1050 * ax25_bind(): uses old (6 digipeater) socket structure.
1052 if ((addr_len
< sizeof(struct sockaddr_ax25
) + sizeof(ax25_address
) * 6) ||
1053 (addr_len
> sizeof(struct full_sockaddr_ax25
)))
1056 if (addr
->fsa_ax25
.sax25_family
!= AF_AX25
)
1059 user
= ax25_findbyuid(current_euid());
1064 if (ax25_uid_policy
&& !capable(CAP_NET_ADMIN
))
1067 call
= addr
->fsa_ax25
.sax25_call
;
1072 ax25
= sk_to_ax25(sk
);
1073 if (!sock_flag(sk
, SOCK_ZAPPED
)) {
1078 ax25
->source_addr
= call
;
1081 * User already set interface with SO_BINDTODEVICE
1083 if (ax25
->ax25_dev
!= NULL
)
1086 if (addr_len
> sizeof(struct sockaddr_ax25
) && addr
->fsa_ax25
.sax25_ndigis
== 1) {
1087 if (ax25cmp(&addr
->fsa_digipeater
[0], &null_ax25_address
) != 0 &&
1088 (ax25_dev
= ax25_addr_ax25dev(&addr
->fsa_digipeater
[0])) == NULL
) {
1089 err
= -EADDRNOTAVAIL
;
1093 if ((ax25_dev
= ax25_addr_ax25dev(&addr
->fsa_ax25
.sax25_call
)) == NULL
) {
1094 err
= -EADDRNOTAVAIL
;
1099 if (ax25_dev
!= NULL
)
1100 ax25_fillin_cb(ax25
, ax25_dev
);
1104 sock_reset_flag(sk
, SOCK_ZAPPED
);
1113 * FIXME: nonblock behaviour looks like it may have a bug.
1115 static int __must_check
ax25_connect(struct socket
*sock
,
1116 struct sockaddr
*uaddr
, int addr_len
, int flags
)
1118 struct sock
*sk
= sock
->sk
;
1119 ax25_cb
*ax25
= sk_to_ax25(sk
), *ax25t
;
1120 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)uaddr
;
1121 ax25_digi
*digi
= NULL
;
1122 int ct
= 0, err
= 0;
1125 * some sanity checks. code further down depends on this
1128 if (addr_len
== sizeof(struct sockaddr_ax25
))
1129 /* support for this will go away in early 2.5.x
1130 * ax25_connect(): uses obsolete socket structure
1133 else if (addr_len
!= sizeof(struct full_sockaddr_ax25
))
1134 /* support for old structure may go away some time
1135 * ax25_connect(): uses old (6 digipeater) socket structure.
1137 if ((addr_len
< sizeof(struct sockaddr_ax25
) + sizeof(ax25_address
) * 6) ||
1138 (addr_len
> sizeof(struct full_sockaddr_ax25
)))
1142 if (fsa
->fsa_ax25
.sax25_family
!= AF_AX25
)
1147 /* deal with restarts */
1148 if (sock
->state
== SS_CONNECTING
) {
1149 switch (sk
->sk_state
) {
1150 case TCP_SYN_SENT
: /* still trying */
1154 case TCP_ESTABLISHED
: /* connection established */
1155 sock
->state
= SS_CONNECTED
;
1158 case TCP_CLOSE
: /* connection refused */
1159 sock
->state
= SS_UNCONNECTED
;
1160 err
= -ECONNREFUSED
;
1165 if (sk
->sk_state
== TCP_ESTABLISHED
&& sk
->sk_type
== SOCK_SEQPACKET
) {
1166 err
= -EISCONN
; /* No reconnect on a seqpacket socket */
1170 sk
->sk_state
= TCP_CLOSE
;
1171 sock
->state
= SS_UNCONNECTED
;
1173 kfree(ax25
->digipeat
);
1174 ax25
->digipeat
= NULL
;
1177 * Handle digi-peaters to be used.
1179 if (addr_len
> sizeof(struct sockaddr_ax25
) &&
1180 fsa
->fsa_ax25
.sax25_ndigis
!= 0) {
1181 /* Valid number of digipeaters ? */
1182 if (fsa
->fsa_ax25
.sax25_ndigis
< 1 || fsa
->fsa_ax25
.sax25_ndigis
> AX25_MAX_DIGIS
) {
1187 if ((digi
= kmalloc(sizeof(ax25_digi
), GFP_KERNEL
)) == NULL
) {
1192 digi
->ndigi
= fsa
->fsa_ax25
.sax25_ndigis
;
1193 digi
->lastrepeat
= -1;
1195 while (ct
< fsa
->fsa_ax25
.sax25_ndigis
) {
1196 if ((fsa
->fsa_digipeater
[ct
].ax25_call
[6] &
1197 AX25_HBIT
) && ax25
->iamdigi
) {
1198 digi
->repeated
[ct
] = 1;
1199 digi
->lastrepeat
= ct
;
1201 digi
->repeated
[ct
] = 0;
1203 digi
->calls
[ct
] = fsa
->fsa_digipeater
[ct
];
1209 * Must bind first - autobinding in this may or may not work. If
1210 * the socket is already bound, check to see if the device has
1211 * been filled in, error if it hasn't.
1213 if (sock_flag(sk
, SOCK_ZAPPED
)) {
1214 /* check if we can remove this feature. It is broken. */
1215 printk(KERN_WARNING
"ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1217 if ((err
= ax25_rt_autobind(ax25
, &fsa
->fsa_ax25
.sax25_call
)) < 0) {
1222 ax25_fillin_cb(ax25
, ax25
->ax25_dev
);
1225 if (ax25
->ax25_dev
== NULL
) {
1227 err
= -EHOSTUNREACH
;
1232 if (sk
->sk_type
== SOCK_SEQPACKET
&&
1233 (ax25t
=ax25_find_cb(&ax25
->source_addr
, &fsa
->fsa_ax25
.sax25_call
, digi
,
1234 ax25
->ax25_dev
->dev
))) {
1236 err
= -EADDRINUSE
; /* Already such a connection */
1241 ax25
->dest_addr
= fsa
->fsa_ax25
.sax25_call
;
1242 ax25
->digipeat
= digi
;
1244 /* First the easy one */
1245 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
1246 sock
->state
= SS_CONNECTED
;
1247 sk
->sk_state
= TCP_ESTABLISHED
;
1251 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1252 sock
->state
= SS_CONNECTING
;
1253 sk
->sk_state
= TCP_SYN_SENT
;
1255 switch (ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
]) {
1256 case AX25_PROTO_STD_SIMPLEX
:
1257 case AX25_PROTO_STD_DUPLEX
:
1258 ax25_std_establish_data_link(ax25
);
1261 #ifdef CONFIG_AX25_DAMA_SLAVE
1262 case AX25_PROTO_DAMA_SLAVE
:
1263 ax25
->modulus
= AX25_MODULUS
;
1264 ax25
->window
= ax25
->ax25_dev
->values
[AX25_VALUES_WINDOW
];
1265 if (ax25
->ax25_dev
->dama
.slave
)
1266 ax25_ds_establish_data_link(ax25
);
1268 ax25_std_establish_data_link(ax25
);
1273 ax25
->state
= AX25_STATE_1
;
1275 ax25_start_heartbeat(ax25
);
1278 if (sk
->sk_state
!= TCP_ESTABLISHED
&& (flags
& O_NONBLOCK
)) {
1283 if (sk
->sk_state
== TCP_SYN_SENT
) {
1287 prepare_to_wait(sk_sleep(sk
), &wait
,
1288 TASK_INTERRUPTIBLE
);
1289 if (sk
->sk_state
!= TCP_SYN_SENT
)
1291 if (!signal_pending(current
)) {
1300 finish_wait(sk_sleep(sk
), &wait
);
1306 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1307 /* Not in ABM, not in WAIT_UA -> failed */
1308 sock
->state
= SS_UNCONNECTED
;
1309 err
= sock_error(sk
); /* Always set at this point */
1313 sock
->state
= SS_CONNECTED
;
1322 static int ax25_accept(struct socket
*sock
, struct socket
*newsock
, int flags
,
1325 struct sk_buff
*skb
;
1331 if (sock
->state
!= SS_UNCONNECTED
)
1334 if ((sk
= sock
->sk
) == NULL
)
1338 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
1343 if (sk
->sk_state
!= TCP_LISTEN
) {
1349 * The read queue this time is holding sockets ready to use
1350 * hooked into the SABM we saved
1353 prepare_to_wait(sk_sleep(sk
), &wait
, TASK_INTERRUPTIBLE
);
1354 skb
= skb_dequeue(&sk
->sk_receive_queue
);
1358 if (flags
& O_NONBLOCK
) {
1362 if (!signal_pending(current
)) {
1371 finish_wait(sk_sleep(sk
), &wait
);
1377 sock_graft(newsk
, newsock
);
1379 /* Now attach up the new socket */
1381 sk
->sk_ack_backlog
--;
1382 newsock
->state
= SS_CONNECTED
;
1390 static int ax25_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
1393 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)uaddr
;
1394 struct sock
*sk
= sock
->sk
;
1395 unsigned char ndigi
, i
;
1399 memset(fsa
, 0, sizeof(*fsa
));
1401 ax25
= sk_to_ax25(sk
);
1404 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1409 fsa
->fsa_ax25
.sax25_family
= AF_AX25
;
1410 fsa
->fsa_ax25
.sax25_call
= ax25
->dest_addr
;
1412 if (ax25
->digipeat
!= NULL
) {
1413 ndigi
= ax25
->digipeat
->ndigi
;
1414 fsa
->fsa_ax25
.sax25_ndigis
= ndigi
;
1415 for (i
= 0; i
< ndigi
; i
++)
1416 fsa
->fsa_digipeater
[i
] =
1417 ax25
->digipeat
->calls
[i
];
1420 fsa
->fsa_ax25
.sax25_family
= AF_AX25
;
1421 fsa
->fsa_ax25
.sax25_call
= ax25
->source_addr
;
1422 fsa
->fsa_ax25
.sax25_ndigis
= 1;
1423 if (ax25
->ax25_dev
!= NULL
) {
1424 memcpy(&fsa
->fsa_digipeater
[0],
1425 ax25
->ax25_dev
->dev
->dev_addr
, AX25_ADDR_LEN
);
1427 fsa
->fsa_digipeater
[0] = null_ax25_address
;
1430 err
= sizeof (struct full_sockaddr_ax25
);
1438 static int ax25_sendmsg(struct socket
*sock
, struct msghdr
*msg
, size_t len
)
1440 DECLARE_SOCKADDR(struct sockaddr_ax25
*, usax
, msg
->msg_name
);
1441 struct sock
*sk
= sock
->sk
;
1442 struct sockaddr_ax25 sax
;
1443 struct sk_buff
*skb
;
1444 ax25_digi dtmp
, *dp
;
1447 int lv
, err
, addr_len
= msg
->msg_namelen
;
1449 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_EOR
|MSG_CMSG_COMPAT
))
1453 ax25
= sk_to_ax25(sk
);
1455 if (sock_flag(sk
, SOCK_ZAPPED
)) {
1456 err
= -EADDRNOTAVAIL
;
1460 if (sk
->sk_shutdown
& SEND_SHUTDOWN
) {
1461 send_sig(SIGPIPE
, current
, 0);
1466 if (ax25
->ax25_dev
== NULL
) {
1471 if (len
> ax25
->ax25_dev
->dev
->mtu
) {
1477 if (usax
->sax25_family
!= AF_AX25
) {
1482 if (addr_len
== sizeof(struct sockaddr_ax25
))
1483 /* ax25_sendmsg(): uses obsolete socket structure */
1485 else if (addr_len
!= sizeof(struct full_sockaddr_ax25
))
1486 /* support for old structure may go away some time
1487 * ax25_sendmsg(): uses old (6 digipeater)
1490 if ((addr_len
< sizeof(struct sockaddr_ax25
) + sizeof(ax25_address
) * 6) ||
1491 (addr_len
> sizeof(struct full_sockaddr_ax25
))) {
1497 if (addr_len
> sizeof(struct sockaddr_ax25
) && usax
->sax25_ndigis
!= 0) {
1499 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)usax
;
1501 /* Valid number of digipeaters ? */
1502 if (usax
->sax25_ndigis
< 1 || usax
->sax25_ndigis
> AX25_MAX_DIGIS
) {
1507 dtmp
.ndigi
= usax
->sax25_ndigis
;
1509 while (ct
< usax
->sax25_ndigis
) {
1510 dtmp
.repeated
[ct
] = 0;
1511 dtmp
.calls
[ct
] = fsa
->fsa_digipeater
[ct
];
1515 dtmp
.lastrepeat
= 0;
1519 if (sk
->sk_type
== SOCK_SEQPACKET
&&
1520 ax25cmp(&ax25
->dest_addr
, &sax
.sax25_call
)) {
1524 if (usax
->sax25_ndigis
== 0)
1530 * FIXME: 1003.1g - if the socket is like this because
1531 * it has become closed (not started closed) and is VC
1532 * we ought to SIGPIPE, EPIPE
1534 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1538 sax
.sax25_family
= AF_AX25
;
1539 sax
.sax25_call
= ax25
->dest_addr
;
1540 dp
= ax25
->digipeat
;
1543 /* Build a packet */
1544 /* Assume the worst case */
1545 size
= len
+ ax25
->ax25_dev
->dev
->hard_header_len
;
1547 skb
= sock_alloc_send_skb(sk
, size
, msg
->msg_flags
&MSG_DONTWAIT
, &err
);
1551 skb_reserve(skb
, size
- len
);
1553 /* User data follows immediately after the AX.25 data */
1554 if (memcpy_from_msg(skb_put(skb
, len
), msg
, len
)) {
1560 skb_reset_network_header(skb
);
1562 /* Add the PID if one is not supplied by the user in the skb */
1564 *(u8
*)skb_push(skb
, 1) = sk
->sk_protocol
;
1566 if (sk
->sk_type
== SOCK_SEQPACKET
) {
1567 /* Connected mode sockets go via the LAPB machine */
1568 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1574 /* Shove it onto the queue and kick */
1575 ax25_output(ax25
, ax25
->paclen
, skb
);
1581 skb_push(skb
, 1 + ax25_addr_size(dp
));
1583 /* Building AX.25 Header */
1585 /* Build an AX.25 header */
1586 lv
= ax25_addr_build(skb
->data
, &ax25
->source_addr
, &sax
.sax25_call
,
1587 dp
, AX25_COMMAND
, AX25_MODULUS
);
1589 skb_set_transport_header(skb
, lv
);
1591 *skb_transport_header(skb
) = AX25_UI
;
1593 /* Datagram frames go straight out of the door as UI */
1594 ax25_queue_xmit(skb
, ax25
->ax25_dev
->dev
);
1604 static int ax25_recvmsg(struct socket
*sock
, struct msghdr
*msg
, size_t size
,
1607 struct sock
*sk
= sock
->sk
;
1608 struct sk_buff
*skb
;
1614 * This works for seqpacket too. The receiver has ordered the
1615 * queue for us! We do one quick check first though
1617 if (sk
->sk_type
== SOCK_SEQPACKET
&& sk
->sk_state
!= TCP_ESTABLISHED
) {
1622 /* Now we can treat all alike */
1623 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
1624 flags
& MSG_DONTWAIT
, &err
);
1628 if (!sk_to_ax25(sk
)->pidincl
)
1629 skb_pull(skb
, 1); /* Remove PID */
1631 skb_reset_transport_header(skb
);
1634 if (copied
> size
) {
1636 msg
->msg_flags
|= MSG_TRUNC
;
1639 skb_copy_datagram_msg(skb
, 0, msg
, copied
);
1641 if (msg
->msg_name
) {
1644 const unsigned char *mac
= skb_mac_header(skb
);
1645 DECLARE_SOCKADDR(struct sockaddr_ax25
*, sax
, msg
->msg_name
);
1647 memset(sax
, 0, sizeof(struct full_sockaddr_ax25
));
1648 ax25_addr_parse(mac
+ 1, skb
->data
- mac
- 1, &src
, NULL
,
1650 sax
->sax25_family
= AF_AX25
;
1651 /* We set this correctly, even though we may not let the
1652 application know the digi calls further down (because it
1653 did NOT ask to know them). This could get political... **/
1654 sax
->sax25_ndigis
= digi
.ndigi
;
1655 sax
->sax25_call
= src
;
1657 if (sax
->sax25_ndigis
!= 0) {
1659 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)sax
;
1661 for (ct
= 0; ct
< digi
.ndigi
; ct
++)
1662 fsa
->fsa_digipeater
[ct
] = digi
.calls
[ct
];
1664 msg
->msg_namelen
= sizeof(struct full_sockaddr_ax25
);
1667 skb_free_datagram(sk
, skb
);
1676 static int ax25_shutdown(struct socket
*sk
, int how
)
1678 /* FIXME - generate DM and RNR states */
1682 static int ax25_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1684 struct sock
*sk
= sock
->sk
;
1685 void __user
*argp
= (void __user
*)arg
;
1693 amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
1696 res
= put_user(amount
, (int __user
*)argp
);
1701 struct sk_buff
*skb
;
1703 /* These two are safe on a single CPU system as only user tasks fiddle here */
1704 if ((skb
= skb_peek(&sk
->sk_receive_queue
)) != NULL
)
1706 res
= put_user(amount
, (int __user
*) argp
);
1711 res
= sock_get_timestamp(sk
, argp
);
1715 res
= sock_get_timestampns(sk
, argp
);
1718 case SIOCAX25ADDUID
: /* Add a uid to the uid/call map table */
1719 case SIOCAX25DELUID
: /* Delete a uid from the uid/call map table */
1720 case SIOCAX25GETUID
: {
1721 struct sockaddr_ax25 sax25
;
1722 if (copy_from_user(&sax25
, argp
, sizeof(sax25
))) {
1726 res
= ax25_uid_ioctl(cmd
, &sax25
);
1730 case SIOCAX25NOUID
: { /* Set the default policy (default/bar) */
1732 if (!capable(CAP_NET_ADMIN
)) {
1736 if (get_user(amount
, (long __user
*)argp
)) {
1740 if (amount
< 0 || amount
> AX25_NOUID_BLOCK
) {
1744 ax25_uid_policy
= amount
;
1752 if (!capable(CAP_NET_ADMIN
)) {
1756 res
= ax25_rt_ioctl(cmd
, argp
);
1759 case SIOCAX25CTLCON
:
1760 if (!capable(CAP_NET_ADMIN
)) {
1764 res
= ax25_ctl_ioctl(cmd
, argp
);
1767 case SIOCAX25GETINFO
:
1768 case SIOCAX25GETINFOOLD
: {
1769 ax25_cb
*ax25
= sk_to_ax25(sk
);
1770 struct ax25_info_struct ax25_info
;
1772 ax25_info
.t1
= ax25
->t1
/ HZ
;
1773 ax25_info
.t2
= ax25
->t2
/ HZ
;
1774 ax25_info
.t3
= ax25
->t3
/ HZ
;
1775 ax25_info
.idle
= ax25
->idle
/ (60 * HZ
);
1776 ax25_info
.n2
= ax25
->n2
;
1777 ax25_info
.t1timer
= ax25_display_timer(&ax25
->t1timer
) / HZ
;
1778 ax25_info
.t2timer
= ax25_display_timer(&ax25
->t2timer
) / HZ
;
1779 ax25_info
.t3timer
= ax25_display_timer(&ax25
->t3timer
) / HZ
;
1780 ax25_info
.idletimer
= ax25_display_timer(&ax25
->idletimer
) / (60 * HZ
);
1781 ax25_info
.n2count
= ax25
->n2count
;
1782 ax25_info
.state
= ax25
->state
;
1783 ax25_info
.rcv_q
= sk_rmem_alloc_get(sk
);
1784 ax25_info
.snd_q
= sk_wmem_alloc_get(sk
);
1785 ax25_info
.vs
= ax25
->vs
;
1786 ax25_info
.vr
= ax25
->vr
;
1787 ax25_info
.va
= ax25
->va
;
1788 ax25_info
.vs_max
= ax25
->vs
; /* reserved */
1789 ax25_info
.paclen
= ax25
->paclen
;
1790 ax25_info
.window
= ax25
->window
;
1792 /* old structure? */
1793 if (cmd
== SIOCAX25GETINFOOLD
) {
1794 static int warned
= 0;
1796 printk(KERN_INFO
"%s uses old SIOCAX25GETINFO\n",
1801 if (copy_to_user(argp
, &ax25_info
, sizeof(struct ax25_info_struct_deprecated
))) {
1806 if (copy_to_user(argp
, &ax25_info
, sizeof(struct ax25_info_struct
))) {
1815 case SIOCAX25ADDFWD
:
1816 case SIOCAX25DELFWD
: {
1817 struct ax25_fwd_struct ax25_fwd
;
1818 if (!capable(CAP_NET_ADMIN
)) {
1822 if (copy_from_user(&ax25_fwd
, argp
, sizeof(ax25_fwd
))) {
1826 res
= ax25_fwd_ioctl(cmd
, &ax25_fwd
);
1832 case SIOCGIFDSTADDR
:
1833 case SIOCSIFDSTADDR
:
1834 case SIOCGIFBRDADDR
:
1835 case SIOCSIFBRDADDR
:
1836 case SIOCGIFNETMASK
:
1837 case SIOCSIFNETMASK
:
1852 #ifdef CONFIG_PROC_FS
1854 static void *ax25_info_start(struct seq_file
*seq
, loff_t
*pos
)
1855 __acquires(ax25_list_lock
)
1857 spin_lock_bh(&ax25_list_lock
);
1858 return seq_hlist_start(&ax25_list
, *pos
);
1861 static void *ax25_info_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1863 return seq_hlist_next(v
, &ax25_list
, pos
);
1866 static void ax25_info_stop(struct seq_file
*seq
, void *v
)
1867 __releases(ax25_list_lock
)
1869 spin_unlock_bh(&ax25_list_lock
);
1872 static int ax25_info_show(struct seq_file
*seq
, void *v
)
1874 ax25_cb
*ax25
= hlist_entry(v
, struct ax25_cb
, ax25_node
);
1881 * 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
1884 seq_printf(seq
, "%8.8lx %s %s%s ",
1886 ax25
->ax25_dev
== NULL
? "???" : ax25
->ax25_dev
->dev
->name
,
1887 ax2asc(buf
, &ax25
->source_addr
),
1888 ax25
->iamdigi
? "*":"");
1889 seq_printf(seq
, "%s", ax2asc(buf
, &ax25
->dest_addr
));
1891 for (k
=0; (ax25
->digipeat
!= NULL
) && (k
< ax25
->digipeat
->ndigi
); k
++) {
1892 seq_printf(seq
, ",%s%s",
1893 ax2asc(buf
, &ax25
->digipeat
->calls
[k
]),
1894 ax25
->digipeat
->repeated
[k
]? "*":"");
1897 seq_printf(seq
, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1899 ax25
->vs
, ax25
->vr
, ax25
->va
,
1900 ax25_display_timer(&ax25
->t1timer
) / HZ
, ax25
->t1
/ HZ
,
1901 ax25_display_timer(&ax25
->t2timer
) / HZ
, ax25
->t2
/ HZ
,
1902 ax25_display_timer(&ax25
->t3timer
) / HZ
, ax25
->t3
/ HZ
,
1903 ax25_display_timer(&ax25
->idletimer
) / (60 * HZ
),
1904 ax25
->idle
/ (60 * HZ
),
1905 ax25
->n2count
, ax25
->n2
,
1910 if (ax25
->sk
!= NULL
) {
1911 seq_printf(seq
, " %d %d %lu\n",
1912 sk_wmem_alloc_get(ax25
->sk
),
1913 sk_rmem_alloc_get(ax25
->sk
),
1914 sock_i_ino(ax25
->sk
));
1916 seq_puts(seq
, " * * *\n");
1921 static const struct seq_operations ax25_info_seqops
= {
1922 .start
= ax25_info_start
,
1923 .next
= ax25_info_next
,
1924 .stop
= ax25_info_stop
,
1925 .show
= ax25_info_show
,
1929 static const struct net_proto_family ax25_family_ops
= {
1931 .create
= ax25_create
,
1932 .owner
= THIS_MODULE
,
1935 static const struct proto_ops ax25_proto_ops
= {
1937 .owner
= THIS_MODULE
,
1938 .release
= ax25_release
,
1940 .connect
= ax25_connect
,
1941 .socketpair
= sock_no_socketpair
,
1942 .accept
= ax25_accept
,
1943 .getname
= ax25_getname
,
1944 .poll
= datagram_poll
,
1945 .ioctl
= ax25_ioctl
,
1946 .listen
= ax25_listen
,
1947 .shutdown
= ax25_shutdown
,
1948 .setsockopt
= ax25_setsockopt
,
1949 .getsockopt
= ax25_getsockopt
,
1950 .sendmsg
= ax25_sendmsg
,
1951 .recvmsg
= ax25_recvmsg
,
1952 .mmap
= sock_no_mmap
,
1953 .sendpage
= sock_no_sendpage
,
1957 * Called by socket.c on kernel start up
1959 static struct packet_type ax25_packet_type __read_mostly
= {
1960 .type
= cpu_to_be16(ETH_P_AX25
),
1961 .func
= ax25_kiss_rcv
,
1964 static struct notifier_block ax25_dev_notifier
= {
1965 .notifier_call
= ax25_device_event
,
1968 static int __init
ax25_init(void)
1970 int rc
= proto_register(&ax25_proto
, 0);
1975 sock_register(&ax25_family_ops
);
1976 dev_add_pack(&ax25_packet_type
);
1977 register_netdevice_notifier(&ax25_dev_notifier
);
1979 proc_create_seq("ax25_route", 0444, init_net
.proc_net
, &ax25_rt_seqops
);
1980 proc_create_seq("ax25", 0444, init_net
.proc_net
, &ax25_info_seqops
);
1981 proc_create_seq("ax25_calls", 0444, init_net
.proc_net
,
1986 module_init(ax25_init
);
1989 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1990 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
1991 MODULE_LICENSE("GPL");
1992 MODULE_ALIAS_NETPROTO(PF_AX25
);
1994 static void __exit
ax25_exit(void)
1996 remove_proc_entry("ax25_route", init_net
.proc_net
);
1997 remove_proc_entry("ax25", init_net
.proc_net
);
1998 remove_proc_entry("ax25_calls", init_net
.proc_net
);
2000 unregister_netdevice_notifier(&ax25_dev_notifier
);
2002 dev_remove_pack(&ax25_packet_type
);
2004 sock_unregister(PF_AX25
);
2005 proto_unregister(&ax25_proto
);
2011 module_exit(ax25_exit
);