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/config.h>
17 #include <linux/capability.h>
18 #include <linux/module.h>
19 #include <linux/errno.h>
20 #include <linux/types.h>
21 #include <linux/socket.h>
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/timer.h>
26 #include <linux/string.h>
27 #include <linux/smp_lock.h>
28 #include <linux/sockios.h>
29 #include <linux/net.h>
31 #include <linux/inet.h>
32 #include <linux/netdevice.h>
33 #include <linux/if_arp.h>
34 #include <linux/skbuff.h>
36 #include <asm/uaccess.h>
37 #include <asm/system.h>
38 #include <linux/fcntl.h>
39 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
41 #include <linux/interrupt.h>
42 #include <linux/notifier.h>
43 #include <linux/proc_fs.h>
44 #include <linux/stat.h>
45 #include <linux/netfilter.h>
46 #include <linux/sysctl.h>
47 #include <linux/init.h>
48 #include <linux/spinlock.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
);
91 ax25_for_each(s
, node
, &ax25_list
) {
92 if (s
->ax25_dev
== ax25_dev
) {
94 ax25_disconnect(s
, ENETUNREACH
);
97 spin_unlock_bh(&ax25_list_lock
);
101 * Handle device status changes.
103 static int ax25_device_event(struct notifier_block
*this, unsigned long event
,
106 struct net_device
*dev
= (struct net_device
*)ptr
;
108 /* Reject non AX.25 devices */
109 if (dev
->type
!= ARPHRD_AX25
)
114 ax25_dev_device_up(dev
);
117 ax25_kill_by_device(dev
);
118 ax25_rt_device_down(dev
);
119 ax25_dev_device_down(dev
);
129 * Add a socket to the bound sockets list.
131 void ax25_cb_add(ax25_cb
*ax25
)
133 spin_lock_bh(&ax25_list_lock
);
135 hlist_add_head(&ax25
->ax25_node
, &ax25_list
);
136 spin_unlock_bh(&ax25_list_lock
);
140 * Find a socket that wants to accept the SABM we have just
143 struct sock
*ax25_find_listener(ax25_address
*addr
, int digi
,
144 struct net_device
*dev
, int type
)
147 struct hlist_node
*node
;
149 spin_lock_bh(&ax25_list_lock
);
150 ax25_for_each(s
, node
, &ax25_list
) {
151 if ((s
->iamdigi
&& !digi
) || (!s
->iamdigi
&& digi
))
153 if (s
->sk
&& !ax25cmp(&s
->source_addr
, addr
) &&
154 s
->sk
->sk_type
== type
&& s
->sk
->sk_state
== TCP_LISTEN
) {
155 /* If device is null we match any device */
156 if (s
->ax25_dev
== NULL
|| s
->ax25_dev
->dev
== dev
) {
158 spin_unlock_bh(&ax25_list_lock
);
163 spin_unlock_bh(&ax25_list_lock
);
169 * Find an AX.25 socket given both ends.
171 struct sock
*ax25_get_socket(ax25_address
*my_addr
, ax25_address
*dest_addr
,
174 struct sock
*sk
= NULL
;
176 struct hlist_node
*node
;
178 spin_lock_bh(&ax25_list_lock
);
179 ax25_for_each(s
, node
, &ax25_list
) {
180 if (s
->sk
&& !ax25cmp(&s
->source_addr
, my_addr
) &&
181 !ax25cmp(&s
->dest_addr
, dest_addr
) &&
182 s
->sk
->sk_type
== type
) {
189 spin_unlock_bh(&ax25_list_lock
);
195 * Find an AX.25 control block given both ends. It will only pick up
196 * floating AX.25 control blocks or non Raw socket bound control blocks.
198 ax25_cb
*ax25_find_cb(ax25_address
*src_addr
, ax25_address
*dest_addr
,
199 ax25_digi
*digi
, struct net_device
*dev
)
202 struct hlist_node
*node
;
204 spin_lock_bh(&ax25_list_lock
);
205 ax25_for_each(s
, node
, &ax25_list
) {
206 if (s
->sk
&& s
->sk
->sk_type
!= SOCK_SEQPACKET
)
208 if (s
->ax25_dev
== NULL
)
210 if (ax25cmp(&s
->source_addr
, src_addr
) == 0 && ax25cmp(&s
->dest_addr
, dest_addr
) == 0 && s
->ax25_dev
->dev
== dev
) {
211 if (digi
!= NULL
&& digi
->ndigi
!= 0) {
212 if (s
->digipeat
== NULL
)
214 if (ax25digicmp(s
->digipeat
, digi
) != 0)
217 if (s
->digipeat
!= NULL
&& s
->digipeat
->ndigi
!= 0)
221 spin_unlock_bh(&ax25_list_lock
);
226 spin_unlock_bh(&ax25_list_lock
);
231 EXPORT_SYMBOL(ax25_find_cb
);
233 void ax25_send_to_raw(ax25_address
*addr
, struct sk_buff
*skb
, int proto
)
236 struct sk_buff
*copy
;
237 struct hlist_node
*node
;
239 spin_lock_bh(&ax25_list_lock
);
240 ax25_for_each(s
, node
, &ax25_list
) {
241 if (s
->sk
!= NULL
&& ax25cmp(&s
->source_addr
, addr
) == 0 &&
242 s
->sk
->sk_type
== SOCK_RAW
&&
243 s
->sk
->sk_protocol
== proto
&&
244 s
->ax25_dev
->dev
== skb
->dev
&&
245 atomic_read(&s
->sk
->sk_rmem_alloc
) <= s
->sk
->sk_rcvbuf
) {
246 if ((copy
= skb_clone(skb
, GFP_ATOMIC
)) == NULL
)
248 if (sock_queue_rcv_skb(s
->sk
, copy
) != 0)
252 spin_unlock_bh(&ax25_list_lock
);
258 void ax25_destroy_socket(ax25_cb
*);
261 * Handler for deferred kills.
263 static void ax25_destroy_timer(unsigned long data
)
265 ax25_cb
*ax25
=(ax25_cb
*)data
;
272 ax25_destroy_socket(ax25
);
278 * This is called from user mode and the timers. Thus it protects itself
279 * against interrupt users but doesn't worry about being called during
280 * work. Once it is removed from the queue no interrupt or bottom half
281 * will touch it and we are (fairly 8-) ) safe.
283 void ax25_destroy_socket(ax25_cb
*ax25
)
289 ax25_stop_heartbeat(ax25
);
290 ax25_stop_t1timer(ax25
);
291 ax25_stop_t2timer(ax25
);
292 ax25_stop_t3timer(ax25
);
293 ax25_stop_idletimer(ax25
);
295 ax25_clear_queues(ax25
); /* Flush the queues */
297 if (ax25
->sk
!= NULL
) {
298 while ((skb
= skb_dequeue(&ax25
->sk
->sk_receive_queue
)) != NULL
) {
299 if (skb
->sk
!= ax25
->sk
) {
300 /* A pending connection */
301 ax25_cb
*sax25
= ax25_sk(skb
->sk
);
303 /* Queue the unaccepted socket for death */
304 sock_orphan(skb
->sk
);
306 ax25_start_heartbeat(sax25
);
307 sax25
->state
= AX25_STATE_0
;
312 skb_queue_purge(&ax25
->sk
->sk_write_queue
);
315 if (ax25
->sk
!= NULL
) {
316 if (atomic_read(&ax25
->sk
->sk_wmem_alloc
) ||
317 atomic_read(&ax25
->sk
->sk_rmem_alloc
)) {
318 /* Defer: outstanding buffers */
319 init_timer(&ax25
->dtimer
);
320 ax25
->dtimer
.expires
= jiffies
+ 2 * HZ
;
321 ax25
->dtimer
.function
= ax25_destroy_timer
;
322 ax25
->dtimer
.data
= (unsigned long)ax25
;
323 add_timer(&ax25
->dtimer
);
325 struct sock
*sk
=ax25
->sk
;
335 * dl1bke 960311: set parameters for existing AX.25 connections,
336 * includes a KILL command to abort any connection.
337 * VERY useful for debugging ;-)
339 static int ax25_ctl_ioctl(const unsigned int cmd
, void __user
*arg
)
341 struct ax25_ctl_struct ax25_ctl
;
347 if (copy_from_user(&ax25_ctl
, arg
, sizeof(ax25_ctl
)))
350 if ((ax25_dev
= ax25_addr_ax25dev(&ax25_ctl
.port_addr
)) == NULL
)
353 if (ax25_ctl
.digi_count
> AX25_MAX_DIGIS
)
356 digi
.ndigi
= ax25_ctl
.digi_count
;
357 for (k
= 0; k
< digi
.ndigi
; k
++)
358 digi
.calls
[k
] = ax25_ctl
.digi_addr
[k
];
360 if ((ax25
= ax25_find_cb(&ax25_ctl
.source_addr
, &ax25_ctl
.dest_addr
, &digi
, ax25_dev
->dev
)) == NULL
)
363 switch (ax25_ctl
.cmd
) {
365 ax25_send_control(ax25
, AX25_DISC
, AX25_POLLON
, AX25_COMMAND
);
366 #ifdef CONFIG_AX25_DAMA_SLAVE
367 if (ax25_dev
->dama
.slave
&& ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
] == AX25_PROTO_DAMA_SLAVE
)
370 ax25_disconnect(ax25
, ENETRESET
);
374 if (ax25
->modulus
== AX25_MODULUS
) {
375 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> 7)
378 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> 63)
381 ax25
->window
= ax25_ctl
.arg
;
385 if (ax25_ctl
.arg
< 1)
387 ax25
->rtt
= (ax25_ctl
.arg
* HZ
) / 2;
388 ax25
->t1
= ax25_ctl
.arg
* HZ
;
392 if (ax25_ctl
.arg
< 1)
394 ax25
->t2
= ax25_ctl
.arg
* HZ
;
398 if (ax25_ctl
.arg
< 1 || ax25_ctl
.arg
> 31)
401 ax25
->n2
= ax25_ctl
.arg
;
405 if (ax25_ctl
.arg
< 0)
407 ax25
->t3
= ax25_ctl
.arg
* HZ
;
411 if (ax25_ctl
.arg
< 0)
413 ax25
->idle
= ax25_ctl
.arg
* 60 * HZ
;
417 if (ax25_ctl
.arg
< 16 || ax25_ctl
.arg
> 65535)
419 ax25
->paclen
= ax25_ctl
.arg
;
429 static void ax25_fillin_cb_from_dev(ax25_cb
*ax25
, ax25_dev
*ax25_dev
)
431 ax25
->rtt
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T1
]) / 2;
432 ax25
->t1
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T1
]);
433 ax25
->t2
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T2
]);
434 ax25
->t3
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_T3
]);
435 ax25
->n2
= ax25_dev
->values
[AX25_VALUES_N2
];
436 ax25
->paclen
= ax25_dev
->values
[AX25_VALUES_PACLEN
];
437 ax25
->idle
= msecs_to_jiffies(ax25_dev
->values
[AX25_VALUES_IDLE
]);
438 ax25
->backoff
= ax25_dev
->values
[AX25_VALUES_BACKOFF
];
440 if (ax25_dev
->values
[AX25_VALUES_AXDEFMODE
]) {
441 ax25
->modulus
= AX25_EMODULUS
;
442 ax25
->window
= ax25_dev
->values
[AX25_VALUES_EWINDOW
];
444 ax25
->modulus
= AX25_MODULUS
;
445 ax25
->window
= ax25_dev
->values
[AX25_VALUES_WINDOW
];
450 * Fill in a created AX.25 created control block with the default
451 * values for a particular device.
453 void ax25_fillin_cb(ax25_cb
*ax25
, ax25_dev
*ax25_dev
)
455 ax25
->ax25_dev
= ax25_dev
;
457 if (ax25
->ax25_dev
!= NULL
) {
458 ax25_fillin_cb_from_dev(ax25
, ax25_dev
);
463 * No device, use kernel / AX.25 spec default values
465 ax25
->rtt
= msecs_to_jiffies(AX25_DEF_T1
) / 2;
466 ax25
->t1
= msecs_to_jiffies(AX25_DEF_T1
);
467 ax25
->t2
= msecs_to_jiffies(AX25_DEF_T2
);
468 ax25
->t3
= msecs_to_jiffies(AX25_DEF_T3
);
469 ax25
->n2
= AX25_DEF_N2
;
470 ax25
->paclen
= AX25_DEF_PACLEN
;
471 ax25
->idle
= msecs_to_jiffies(AX25_DEF_IDLE
);
472 ax25
->backoff
= AX25_DEF_BACKOFF
;
474 if (AX25_DEF_AXDEFMODE
) {
475 ax25
->modulus
= AX25_EMODULUS
;
476 ax25
->window
= AX25_DEF_EWINDOW
;
478 ax25
->modulus
= AX25_MODULUS
;
479 ax25
->window
= AX25_DEF_WINDOW
;
484 * Create an empty AX.25 control block.
486 ax25_cb
*ax25_create_cb(void)
490 if ((ax25
= kmalloc(sizeof(*ax25
), GFP_ATOMIC
)) == NULL
)
493 memset(ax25
, 0x00, sizeof(*ax25
));
494 atomic_set(&ax25
->refcount
, 1);
496 skb_queue_head_init(&ax25
->write_queue
);
497 skb_queue_head_init(&ax25
->frag_queue
);
498 skb_queue_head_init(&ax25
->ack_queue
);
499 skb_queue_head_init(&ax25
->reseq_queue
);
501 init_timer(&ax25
->timer
);
502 init_timer(&ax25
->t1timer
);
503 init_timer(&ax25
->t2timer
);
504 init_timer(&ax25
->t3timer
);
505 init_timer(&ax25
->idletimer
);
507 ax25_fillin_cb(ax25
, NULL
);
509 ax25
->state
= AX25_STATE_0
;
515 * Handling for system calls applied via the various interfaces to an
519 static int ax25_setsockopt(struct socket
*sock
, int level
, int optname
,
520 char __user
*optval
, int optlen
)
522 struct sock
*sk
= sock
->sk
;
524 struct net_device
*dev
;
525 char devname
[IFNAMSIZ
];
528 if (level
!= SOL_AX25
)
531 if (optlen
< sizeof(int))
534 if (get_user(opt
, (int __user
*)optval
))
542 if (ax25
->modulus
== AX25_MODULUS
) {
543 if (opt
< 1 || opt
> 7) {
548 if (opt
< 1 || opt
> 63) {
561 ax25
->rtt
= (opt
* HZ
) / 2;
574 if (opt
< 1 || opt
> 31) {
594 ax25
->idle
= opt
* 60 * HZ
;
598 if (opt
< 0 || opt
> 2) {
606 ax25
->modulus
= opt
? AX25_EMODULUS
: AX25_MODULUS
;
610 ax25
->pidincl
= opt
? 1 : 0;
614 ax25
->iamdigi
= opt
? 1 : 0;
618 if (opt
< 16 || opt
> 65535) {
625 case SO_BINDTODEVICE
:
626 if (optlen
> IFNAMSIZ
)
628 if (copy_from_user(devname
, optval
, optlen
)) {
633 dev
= dev_get_by_name(devname
);
639 if (sk
->sk_type
== SOCK_SEQPACKET
&&
640 (sock
->state
!= SS_UNCONNECTED
||
641 sk
->sk_state
== TCP_LISTEN
)) {
642 res
= -EADDRNOTAVAIL
;
647 ax25
->ax25_dev
= ax25_dev_ax25dev(dev
);
648 ax25_fillin_cb(ax25
, ax25
->ax25_dev
);
659 static int ax25_getsockopt(struct socket
*sock
, int level
, int optname
,
660 char __user
*optval
, int __user
*optlen
)
662 struct sock
*sk
= sock
->sk
;
664 struct ax25_dev
*ax25_dev
;
665 char devname
[IFNAMSIZ
];
670 if (level
!= SOL_AX25
)
673 if (get_user(maxlen
, optlen
))
679 valptr
= (void *) &val
;
680 length
= min_t(unsigned int, maxlen
, sizeof(int));
707 val
= ax25
->idle
/ (60 * HZ
);
715 val
= (ax25
->modulus
== AX25_EMODULUS
);
730 case SO_BINDTODEVICE
:
731 ax25_dev
= ax25
->ax25_dev
;
733 if (ax25_dev
!= NULL
&& ax25_dev
->dev
!= NULL
) {
734 strlcpy(devname
, ax25_dev
->dev
->name
, sizeof(devname
));
735 length
= strlen(devname
) + 1;
741 valptr
= (void *) devname
;
750 if (put_user(length
, optlen
))
753 return copy_to_user(optval
, valptr
, length
) ? -EFAULT
: 0;
756 static int ax25_listen(struct socket
*sock
, int backlog
)
758 struct sock
*sk
= sock
->sk
;
762 if (sk
->sk_type
== SOCK_SEQPACKET
&& sk
->sk_state
!= TCP_LISTEN
) {
763 sk
->sk_max_ack_backlog
= backlog
;
764 sk
->sk_state
= TCP_LISTEN
;
776 * XXX: when creating ax25_sock we should update the .obj_size setting
779 static struct proto ax25_proto
= {
781 .owner
= THIS_MODULE
,
782 .obj_size
= sizeof(struct sock
),
785 static int ax25_create(struct socket
*sock
, int protocol
)
790 switch (sock
->type
) {
792 if (protocol
== 0 || protocol
== PF_AX25
)
793 protocol
= AX25_P_TEXT
;
799 case PF_AX25
: /* For CLX */
800 protocol
= AX25_P_TEXT
;
813 return -ESOCKTNOSUPPORT
;
814 #ifdef CONFIG_NETROM_MODULE
816 if (ax25_protocol_is_registered(AX25_P_NETROM
))
817 return -ESOCKTNOSUPPORT
;
819 #ifdef CONFIG_ROSE_MODULE
821 if (ax25_protocol_is_registered(AX25_P_ROSE
))
822 return -ESOCKTNOSUPPORT
;
832 return -ESOCKTNOSUPPORT
;
835 if ((sk
= sk_alloc(PF_AX25
, GFP_ATOMIC
, &ax25_proto
, 1)) == NULL
)
838 ax25
= sk
->sk_protinfo
= ax25_create_cb();
844 sock_init_data(sock
, sk
);
846 sk
->sk_destruct
= ax25_free_sock
;
847 sock
->ops
= &ax25_proto_ops
;
848 sk
->sk_protocol
= protocol
;
855 struct sock
*ax25_make_new(struct sock
*osk
, struct ax25_dev
*ax25_dev
)
858 ax25_cb
*ax25
, *oax25
;
860 if ((sk
= sk_alloc(PF_AX25
, GFP_ATOMIC
, osk
->sk_prot
, 1)) == NULL
)
863 if ((ax25
= ax25_create_cb()) == NULL
) {
868 switch (osk
->sk_type
) {
879 sock_init_data(NULL
, sk
);
881 sk
->sk_destruct
= ax25_free_sock
;
882 sk
->sk_type
= osk
->sk_type
;
883 sk
->sk_socket
= osk
->sk_socket
;
884 sk
->sk_priority
= osk
->sk_priority
;
885 sk
->sk_protocol
= osk
->sk_protocol
;
886 sk
->sk_rcvbuf
= osk
->sk_rcvbuf
;
887 sk
->sk_sndbuf
= osk
->sk_sndbuf
;
888 sk
->sk_state
= TCP_ESTABLISHED
;
889 sk
->sk_sleep
= osk
->sk_sleep
;
890 sock_copy_flags(sk
, osk
);
892 oax25
= ax25_sk(osk
);
894 ax25
->modulus
= oax25
->modulus
;
895 ax25
->backoff
= oax25
->backoff
;
896 ax25
->pidincl
= oax25
->pidincl
;
897 ax25
->iamdigi
= oax25
->iamdigi
;
898 ax25
->rtt
= oax25
->rtt
;
899 ax25
->t1
= oax25
->t1
;
900 ax25
->t2
= oax25
->t2
;
901 ax25
->t3
= oax25
->t3
;
902 ax25
->n2
= oax25
->n2
;
903 ax25
->idle
= oax25
->idle
;
904 ax25
->paclen
= oax25
->paclen
;
905 ax25
->window
= oax25
->window
;
907 ax25
->ax25_dev
= ax25_dev
;
908 ax25
->source_addr
= oax25
->source_addr
;
910 if (oax25
->digipeat
!= NULL
) {
911 if ((ax25
->digipeat
= kmalloc(sizeof(ax25_digi
), GFP_ATOMIC
)) == NULL
) {
917 memcpy(ax25
->digipeat
, oax25
->digipeat
, sizeof(ax25_digi
));
920 sk
->sk_protinfo
= ax25
;
926 static int ax25_release(struct socket
*sock
)
928 struct sock
*sk
= sock
->sk
;
939 if (sk
->sk_type
== SOCK_SEQPACKET
) {
940 switch (ax25
->state
) {
943 ax25_disconnect(ax25
, 0);
945 ax25_destroy_socket(ax25
);
950 ax25_send_control(ax25
, AX25_DISC
, AX25_POLLON
, AX25_COMMAND
);
952 ax25_disconnect(ax25
, 0);
954 ax25_destroy_socket(ax25
);
959 ax25_clear_queues(ax25
);
962 switch (ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
]) {
963 case AX25_PROTO_STD_SIMPLEX
:
964 case AX25_PROTO_STD_DUPLEX
:
965 ax25_send_control(ax25
,
969 ax25_stop_t2timer(ax25
);
970 ax25_stop_t3timer(ax25
);
971 ax25_stop_idletimer(ax25
);
973 #ifdef CONFIG_AX25_DAMA_SLAVE
974 case AX25_PROTO_DAMA_SLAVE
:
975 ax25_stop_t3timer(ax25
);
976 ax25_stop_idletimer(ax25
);
980 ax25_calculate_t1(ax25
);
981 ax25_start_t1timer(ax25
);
982 ax25
->state
= AX25_STATE_2
;
983 sk
->sk_state
= TCP_CLOSE
;
984 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
985 sk
->sk_state_change(sk
);
986 sock_set_flag(sk
, SOCK_DESTROY
);
993 sk
->sk_state
= TCP_CLOSE
;
994 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
995 sk
->sk_state_change(sk
);
996 ax25_destroy_socket(ax25
);
1007 * We support a funny extension here so you can (as root) give any callsign
1008 * digipeated via a local address as source. This hack is obsolete now
1009 * that we've implemented support for SO_BINDTODEVICE. It is however small
1010 * and trivially backward compatible.
1012 static int ax25_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
1014 struct sock
*sk
= sock
->sk
;
1015 struct full_sockaddr_ax25
*addr
= (struct full_sockaddr_ax25
*)uaddr
;
1016 ax25_dev
*ax25_dev
= NULL
;
1017 ax25_uid_assoc
*user
;
1022 if (addr_len
!= sizeof(struct sockaddr_ax25
) &&
1023 addr_len
!= sizeof(struct full_sockaddr_ax25
)) {
1024 /* support for old structure may go away some time */
1025 if ((addr_len
< sizeof(struct sockaddr_ax25
) + sizeof(ax25_address
) * 6) ||
1026 (addr_len
> sizeof(struct full_sockaddr_ax25
))) {
1030 printk(KERN_WARNING
"ax25_bind(): %s uses old (6 digipeater) socket structure.\n",
1034 if (addr
->fsa_ax25
.sax25_family
!= AF_AX25
)
1037 user
= ax25_findbyuid(current
->euid
);
1042 if (ax25_uid_policy
&& !capable(CAP_NET_ADMIN
))
1045 call
= addr
->fsa_ax25
.sax25_call
;
1051 if (!sock_flag(sk
, SOCK_ZAPPED
)) {
1056 ax25
->source_addr
= call
;
1059 * User already set interface with SO_BINDTODEVICE
1061 if (ax25
->ax25_dev
!= NULL
)
1064 if (addr_len
> sizeof(struct sockaddr_ax25
) && addr
->fsa_ax25
.sax25_ndigis
== 1) {
1065 if (ax25cmp(&addr
->fsa_digipeater
[0], &null_ax25_address
) != 0 &&
1066 (ax25_dev
= ax25_addr_ax25dev(&addr
->fsa_digipeater
[0])) == NULL
) {
1067 err
= -EADDRNOTAVAIL
;
1071 if ((ax25_dev
= ax25_addr_ax25dev(&addr
->fsa_ax25
.sax25_call
)) == NULL
) {
1072 err
= -EADDRNOTAVAIL
;
1077 if (ax25_dev
!= NULL
)
1078 ax25_fillin_cb(ax25
, ax25_dev
);
1082 sock_reset_flag(sk
, SOCK_ZAPPED
);
1091 * FIXME: nonblock behaviour looks like it may have a bug.
1093 static int ax25_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
1094 int addr_len
, int flags
)
1096 struct sock
*sk
= sock
->sk
;
1097 ax25_cb
*ax25
= ax25_sk(sk
), *ax25t
;
1098 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)uaddr
;
1099 ax25_digi
*digi
= NULL
;
1100 int ct
= 0, err
= 0;
1103 * some sanity checks. code further down depends on this
1106 if (addr_len
== sizeof(struct sockaddr_ax25
)) {
1107 /* support for this will go away in early 2.5.x */
1108 printk(KERN_WARNING
"ax25_connect(): %s uses obsolete socket structure\n",
1111 else if (addr_len
!= sizeof(struct full_sockaddr_ax25
)) {
1112 /* support for old structure may go away some time */
1113 if ((addr_len
< sizeof(struct sockaddr_ax25
) + sizeof(ax25_address
) * 6) ||
1114 (addr_len
> sizeof(struct full_sockaddr_ax25
))) {
1118 printk(KERN_WARNING
"ax25_connect(): %s uses old (6 digipeater) socket structure.\n",
1122 if (fsa
->fsa_ax25
.sax25_family
!= AF_AX25
)
1127 /* deal with restarts */
1128 if (sock
->state
== SS_CONNECTING
) {
1129 switch (sk
->sk_state
) {
1130 case TCP_SYN_SENT
: /* still trying */
1134 case TCP_ESTABLISHED
: /* connection established */
1135 sock
->state
= SS_CONNECTED
;
1138 case TCP_CLOSE
: /* connection refused */
1139 sock
->state
= SS_UNCONNECTED
;
1140 err
= -ECONNREFUSED
;
1145 if (sk
->sk_state
== TCP_ESTABLISHED
&& sk
->sk_type
== SOCK_SEQPACKET
) {
1146 err
= -EISCONN
; /* No reconnect on a seqpacket socket */
1150 sk
->sk_state
= TCP_CLOSE
;
1151 sock
->state
= SS_UNCONNECTED
;
1153 kfree(ax25
->digipeat
);
1154 ax25
->digipeat
= NULL
;
1157 * Handle digi-peaters to be used.
1159 if (addr_len
> sizeof(struct sockaddr_ax25
) &&
1160 fsa
->fsa_ax25
.sax25_ndigis
!= 0) {
1161 /* Valid number of digipeaters ? */
1162 if (fsa
->fsa_ax25
.sax25_ndigis
< 1 || fsa
->fsa_ax25
.sax25_ndigis
> AX25_MAX_DIGIS
) {
1167 if ((digi
= kmalloc(sizeof(ax25_digi
), GFP_KERNEL
)) == NULL
) {
1172 digi
->ndigi
= fsa
->fsa_ax25
.sax25_ndigis
;
1173 digi
->lastrepeat
= -1;
1175 while (ct
< fsa
->fsa_ax25
.sax25_ndigis
) {
1176 if ((fsa
->fsa_digipeater
[ct
].ax25_call
[6] &
1177 AX25_HBIT
) && ax25
->iamdigi
) {
1178 digi
->repeated
[ct
] = 1;
1179 digi
->lastrepeat
= ct
;
1181 digi
->repeated
[ct
] = 0;
1183 digi
->calls
[ct
] = fsa
->fsa_digipeater
[ct
];
1189 * Must bind first - autobinding in this may or may not work. If
1190 * the socket is already bound, check to see if the device has
1191 * been filled in, error if it hasn't.
1193 if (sock_flag(sk
, SOCK_ZAPPED
)) {
1194 /* check if we can remove this feature. It is broken. */
1195 printk(KERN_WARNING
"ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1197 if ((err
= ax25_rt_autobind(ax25
, &fsa
->fsa_ax25
.sax25_call
)) < 0) {
1202 ax25_fillin_cb(ax25
, ax25
->ax25_dev
);
1205 if (ax25
->ax25_dev
== NULL
) {
1207 err
= -EHOSTUNREACH
;
1212 if (sk
->sk_type
== SOCK_SEQPACKET
&&
1213 (ax25t
=ax25_find_cb(&ax25
->source_addr
, &fsa
->fsa_ax25
.sax25_call
, digi
,
1214 ax25
->ax25_dev
->dev
))) {
1216 err
= -EADDRINUSE
; /* Already such a connection */
1221 ax25
->dest_addr
= fsa
->fsa_ax25
.sax25_call
;
1222 ax25
->digipeat
= digi
;
1224 /* First the easy one */
1225 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
1226 sock
->state
= SS_CONNECTED
;
1227 sk
->sk_state
= TCP_ESTABLISHED
;
1231 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1232 sock
->state
= SS_CONNECTING
;
1233 sk
->sk_state
= TCP_SYN_SENT
;
1235 switch (ax25
->ax25_dev
->values
[AX25_VALUES_PROTOCOL
]) {
1236 case AX25_PROTO_STD_SIMPLEX
:
1237 case AX25_PROTO_STD_DUPLEX
:
1238 ax25_std_establish_data_link(ax25
);
1241 #ifdef CONFIG_AX25_DAMA_SLAVE
1242 case AX25_PROTO_DAMA_SLAVE
:
1243 ax25
->modulus
= AX25_MODULUS
;
1244 ax25
->window
= ax25
->ax25_dev
->values
[AX25_VALUES_WINDOW
];
1245 if (ax25
->ax25_dev
->dama
.slave
)
1246 ax25_ds_establish_data_link(ax25
);
1248 ax25_std_establish_data_link(ax25
);
1253 ax25
->state
= AX25_STATE_1
;
1255 ax25_start_heartbeat(ax25
);
1258 if (sk
->sk_state
!= TCP_ESTABLISHED
&& (flags
& O_NONBLOCK
)) {
1263 if (sk
->sk_state
== TCP_SYN_SENT
) {
1264 struct task_struct
*tsk
= current
;
1265 DECLARE_WAITQUEUE(wait
, tsk
);
1267 add_wait_queue(sk
->sk_sleep
, &wait
);
1269 if (sk
->sk_state
!= TCP_SYN_SENT
)
1271 set_current_state(TASK_INTERRUPTIBLE
);
1273 if (!signal_pending(tsk
)) {
1278 current
->state
= TASK_RUNNING
;
1279 remove_wait_queue(sk
->sk_sleep
, &wait
);
1280 return -ERESTARTSYS
;
1282 current
->state
= TASK_RUNNING
;
1283 remove_wait_queue(sk
->sk_sleep
, &wait
);
1286 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1287 /* Not in ABM, not in WAIT_UA -> failed */
1288 sock
->state
= SS_UNCONNECTED
;
1289 err
= sock_error(sk
); /* Always set at this point */
1293 sock
->state
= SS_CONNECTED
;
1303 static int ax25_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
1305 struct task_struct
*tsk
= current
;
1306 DECLARE_WAITQUEUE(wait
, tsk
);
1307 struct sk_buff
*skb
;
1312 if (sock
->state
!= SS_UNCONNECTED
)
1315 if ((sk
= sock
->sk
) == NULL
)
1319 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
1324 if (sk
->sk_state
!= TCP_LISTEN
) {
1330 * The read queue this time is holding sockets ready to use
1331 * hooked into the SABM we saved
1333 add_wait_queue(sk
->sk_sleep
, &wait
);
1335 skb
= skb_dequeue(&sk
->sk_receive_queue
);
1340 current
->state
= TASK_INTERRUPTIBLE
;
1341 if (flags
& O_NONBLOCK
) {
1342 current
->state
= TASK_RUNNING
;
1343 remove_wait_queue(sk
->sk_sleep
, &wait
);
1344 return -EWOULDBLOCK
;
1346 if (!signal_pending(tsk
)) {
1351 current
->state
= TASK_RUNNING
;
1352 remove_wait_queue(sk
->sk_sleep
, &wait
);
1353 return -ERESTARTSYS
;
1355 current
->state
= TASK_RUNNING
;
1356 remove_wait_queue(sk
->sk_sleep
, &wait
);
1359 newsk
->sk_socket
= newsock
;
1360 newsk
->sk_sleep
= &newsock
->wait
;
1362 /* Now attach up the new socket */
1364 sk
->sk_ack_backlog
--;
1365 newsock
->sk
= newsk
;
1366 newsock
->state
= SS_CONNECTED
;
1374 static int ax25_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
1375 int *uaddr_len
, int peer
)
1377 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)uaddr
;
1378 struct sock
*sk
= sock
->sk
;
1379 unsigned char ndigi
, i
;
1387 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1392 fsa
->fsa_ax25
.sax25_family
= AF_AX25
;
1393 fsa
->fsa_ax25
.sax25_call
= ax25
->dest_addr
;
1394 fsa
->fsa_ax25
.sax25_ndigis
= 0;
1396 if (ax25
->digipeat
!= NULL
) {
1397 ndigi
= ax25
->digipeat
->ndigi
;
1398 fsa
->fsa_ax25
.sax25_ndigis
= ndigi
;
1399 for (i
= 0; i
< ndigi
; i
++)
1400 fsa
->fsa_digipeater
[i
] =
1401 ax25
->digipeat
->calls
[i
];
1404 fsa
->fsa_ax25
.sax25_family
= AF_AX25
;
1405 fsa
->fsa_ax25
.sax25_call
= ax25
->source_addr
;
1406 fsa
->fsa_ax25
.sax25_ndigis
= 1;
1407 if (ax25
->ax25_dev
!= NULL
) {
1408 memcpy(&fsa
->fsa_digipeater
[0],
1409 ax25
->ax25_dev
->dev
->dev_addr
, AX25_ADDR_LEN
);
1411 fsa
->fsa_digipeater
[0] = null_ax25_address
;
1414 *uaddr_len
= sizeof (struct full_sockaddr_ax25
);
1422 static int ax25_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
1423 struct msghdr
*msg
, size_t len
)
1425 struct sockaddr_ax25
*usax
= (struct sockaddr_ax25
*)msg
->msg_name
;
1426 struct sock
*sk
= sock
->sk
;
1427 struct sockaddr_ax25 sax
;
1428 struct sk_buff
*skb
;
1429 ax25_digi dtmp
, *dp
;
1430 unsigned char *asmptr
;
1433 int lv
, err
, addr_len
= msg
->msg_namelen
;
1435 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_EOR
|MSG_CMSG_COMPAT
))
1441 if (sock_flag(sk
, SOCK_ZAPPED
)) {
1442 err
= -EADDRNOTAVAIL
;
1446 if (sk
->sk_shutdown
& SEND_SHUTDOWN
) {
1447 send_sig(SIGPIPE
, current
, 0);
1452 if (ax25
->ax25_dev
== NULL
) {
1457 if (len
> ax25
->ax25_dev
->dev
->mtu
) {
1463 if (usax
->sax25_family
!= AF_AX25
) {
1468 if (addr_len
== sizeof(struct sockaddr_ax25
)) {
1469 printk(KERN_WARNING
"ax25_sendmsg(): %s uses obsolete socket structure\n",
1472 else if (addr_len
!= sizeof(struct full_sockaddr_ax25
)) {
1473 /* support for old structure may go away some time */
1474 if ((addr_len
< sizeof(struct sockaddr_ax25
) + sizeof(ax25_address
) * 6) ||
1475 (addr_len
> sizeof(struct full_sockaddr_ax25
))) {
1480 printk(KERN_WARNING
"ax25_sendmsg(): %s uses old (6 digipeater) socket structure.\n",
1484 if (addr_len
> sizeof(struct sockaddr_ax25
) && usax
->sax25_ndigis
!= 0) {
1486 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)usax
;
1488 /* Valid number of digipeaters ? */
1489 if (usax
->sax25_ndigis
< 1 || usax
->sax25_ndigis
> AX25_MAX_DIGIS
) {
1494 dtmp
.ndigi
= usax
->sax25_ndigis
;
1496 while (ct
< usax
->sax25_ndigis
) {
1497 dtmp
.repeated
[ct
] = 0;
1498 dtmp
.calls
[ct
] = fsa
->fsa_digipeater
[ct
];
1502 dtmp
.lastrepeat
= 0;
1506 if (sk
->sk_type
== SOCK_SEQPACKET
&&
1507 ax25cmp(&ax25
->dest_addr
, &sax
.sax25_call
)) {
1511 if (usax
->sax25_ndigis
== 0)
1517 * FIXME: 1003.1g - if the socket is like this because
1518 * it has become closed (not started closed) and is VC
1519 * we ought to SIGPIPE, EPIPE
1521 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1525 sax
.sax25_family
= AF_AX25
;
1526 sax
.sax25_call
= ax25
->dest_addr
;
1527 dp
= ax25
->digipeat
;
1530 SOCK_DEBUG(sk
, "AX.25: sendto: Addresses built.\n");
1532 /* Build a packet */
1533 SOCK_DEBUG(sk
, "AX.25: sendto: building packet.\n");
1535 /* Assume the worst case */
1536 size
= len
+ ax25
->ax25_dev
->dev
->hard_header_len
;
1538 skb
= sock_alloc_send_skb(sk
, size
, msg
->msg_flags
&MSG_DONTWAIT
, &err
);
1542 skb_reserve(skb
, size
- len
);
1544 SOCK_DEBUG(sk
, "AX.25: Appending user data\n");
1546 /* User data follows immediately after the AX.25 data */
1547 if (memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
)) {
1553 skb
->nh
.raw
= skb
->data
;
1555 /* Add the PID if one is not supplied by the user in the skb */
1556 if (!ax25
->pidincl
) {
1557 asmptr
= skb_push(skb
, 1);
1558 *asmptr
= sk
->sk_protocol
;
1561 SOCK_DEBUG(sk
, "AX.25: Transmitting buffer\n");
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 asmptr
= skb_push(skb
, 1 + ax25_addr_size(dp
));
1580 SOCK_DEBUG(sk
, "Building AX.25 Header (dp=%p).\n", dp
);
1583 SOCK_DEBUG(sk
, "Num digipeaters=%d\n", dp
->ndigi
);
1585 /* Build an AX.25 header */
1586 asmptr
+= (lv
= ax25_addr_build(asmptr
, &ax25
->source_addr
,
1587 &sax
.sax25_call
, dp
,
1588 AX25_COMMAND
, AX25_MODULUS
));
1590 SOCK_DEBUG(sk
, "Built header (%d bytes)\n",lv
);
1592 skb
->h
.raw
= asmptr
;
1594 SOCK_DEBUG(sk
, "base=%p pos=%p\n", skb
->data
, asmptr
);
1598 /* Datagram frames go straight out of the door as UI */
1599 ax25_queue_xmit(skb
, ax25
->ax25_dev
->dev
);
1609 static int ax25_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
1610 struct msghdr
*msg
, size_t size
, int flags
)
1612 struct sock
*sk
= sock
->sk
;
1613 struct sk_buff
*skb
;
1619 * This works for seqpacket too. The receiver has ordered the
1620 * queue for us! We do one quick check first though
1622 if (sk
->sk_type
== SOCK_SEQPACKET
&& sk
->sk_state
!= TCP_ESTABLISHED
) {
1627 /* Now we can treat all alike */
1628 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
1629 flags
& MSG_DONTWAIT
, &err
);
1633 if (!ax25_sk(sk
)->pidincl
)
1634 skb_pull(skb
, 1); /* Remove PID */
1636 skb
->h
.raw
= skb
->data
;
1639 if (copied
> size
) {
1641 msg
->msg_flags
|= MSG_TRUNC
;
1644 skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
1646 if (msg
->msg_namelen
!= 0) {
1647 struct sockaddr_ax25
*sax
= (struct sockaddr_ax25
*)msg
->msg_name
;
1651 ax25_addr_parse(skb
->mac
.raw
+1, skb
->data
-skb
->mac
.raw
-1, &src
, NULL
, &digi
, NULL
, NULL
);
1653 sax
->sax25_family
= AF_AX25
;
1654 /* We set this correctly, even though we may not let the
1655 application know the digi calls further down (because it
1656 did NOT ask to know them). This could get political... **/
1657 sax
->sax25_ndigis
= digi
.ndigi
;
1658 sax
->sax25_call
= src
;
1660 if (sax
->sax25_ndigis
!= 0) {
1662 struct full_sockaddr_ax25
*fsa
= (struct full_sockaddr_ax25
*)sax
;
1664 for (ct
= 0; ct
< digi
.ndigi
; ct
++)
1665 fsa
->fsa_digipeater
[ct
] = digi
.calls
[ct
];
1667 msg
->msg_namelen
= sizeof(struct full_sockaddr_ax25
);
1670 skb_free_datagram(sk
, skb
);
1679 static int ax25_shutdown(struct socket
*sk
, int how
)
1681 /* FIXME - generate DM and RNR states */
1685 static int ax25_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1687 struct sock
*sk
= sock
->sk
;
1688 void __user
*argp
= (void __user
*)arg
;
1695 amount
= sk
->sk_sndbuf
- atomic_read(&sk
->sk_wmem_alloc
);
1698 res
= put_user(amount
, (int __user
*)argp
);
1703 struct sk_buff
*skb
;
1705 /* These two are safe on a single CPU system as only user tasks fiddle here */
1706 if ((skb
= skb_peek(&sk
->sk_receive_queue
)) != NULL
)
1708 res
= put_user(amount
, (int __user
*) argp
);
1713 res
= sock_get_timestamp(sk
, argp
);
1716 case SIOCAX25ADDUID
: /* Add a uid to the uid/call map table */
1717 case SIOCAX25DELUID
: /* Delete a uid from the uid/call map table */
1718 case SIOCAX25GETUID
: {
1719 struct sockaddr_ax25 sax25
;
1720 if (copy_from_user(&sax25
, argp
, sizeof(sax25
))) {
1724 res
= ax25_uid_ioctl(cmd
, &sax25
);
1728 case SIOCAX25NOUID
: { /* Set the default policy (default/bar) */
1730 if (!capable(CAP_NET_ADMIN
)) {
1734 if (get_user(amount
, (long __user
*)argp
)) {
1738 if (amount
> AX25_NOUID_BLOCK
) {
1742 ax25_uid_policy
= amount
;
1750 if (!capable(CAP_NET_ADMIN
)) {
1754 res
= ax25_rt_ioctl(cmd
, argp
);
1757 case SIOCAX25CTLCON
:
1758 if (!capable(CAP_NET_ADMIN
)) {
1762 res
= ax25_ctl_ioctl(cmd
, argp
);
1765 case SIOCAX25GETINFO
:
1766 case SIOCAX25GETINFOOLD
: {
1767 ax25_cb
*ax25
= ax25_sk(sk
);
1768 struct ax25_info_struct ax25_info
;
1770 ax25_info
.t1
= ax25
->t1
/ HZ
;
1771 ax25_info
.t2
= ax25
->t2
/ HZ
;
1772 ax25_info
.t3
= ax25
->t3
/ HZ
;
1773 ax25_info
.idle
= ax25
->idle
/ (60 * HZ
);
1774 ax25_info
.n2
= ax25
->n2
;
1775 ax25_info
.t1timer
= ax25_display_timer(&ax25
->t1timer
) / HZ
;
1776 ax25_info
.t2timer
= ax25_display_timer(&ax25
->t2timer
) / HZ
;
1777 ax25_info
.t3timer
= ax25_display_timer(&ax25
->t3timer
) / HZ
;
1778 ax25_info
.idletimer
= ax25_display_timer(&ax25
->idletimer
) / (60 * HZ
);
1779 ax25_info
.n2count
= ax25
->n2count
;
1780 ax25_info
.state
= ax25
->state
;
1781 ax25_info
.rcv_q
= atomic_read(&sk
->sk_rmem_alloc
);
1782 ax25_info
.snd_q
= atomic_read(&sk
->sk_wmem_alloc
);
1783 ax25_info
.vs
= ax25
->vs
;
1784 ax25_info
.vr
= ax25
->vr
;
1785 ax25_info
.va
= ax25
->va
;
1786 ax25_info
.vs_max
= ax25
->vs
; /* reserved */
1787 ax25_info
.paclen
= ax25
->paclen
;
1788 ax25_info
.window
= ax25
->window
;
1790 /* old structure? */
1791 if (cmd
== SIOCAX25GETINFOOLD
) {
1792 static int warned
= 0;
1794 printk(KERN_INFO
"%s uses old SIOCAX25GETINFO\n",
1799 if (copy_to_user(argp
, &ax25_info
, sizeof(struct ax25_info_struct_deprecated
))) {
1804 if (copy_to_user(argp
, &ax25_info
, sizeof(struct ax25_info_struct
))) {
1813 case SIOCAX25ADDFWD
:
1814 case SIOCAX25DELFWD
: {
1815 struct ax25_fwd_struct ax25_fwd
;
1816 if (!capable(CAP_NET_ADMIN
)) {
1820 if (copy_from_user(&ax25_fwd
, argp
, sizeof(ax25_fwd
))) {
1824 res
= ax25_fwd_ioctl(cmd
, &ax25_fwd
);
1830 case SIOCGIFDSTADDR
:
1831 case SIOCSIFDSTADDR
:
1832 case SIOCGIFBRDADDR
:
1833 case SIOCSIFBRDADDR
:
1834 case SIOCGIFNETMASK
:
1835 case SIOCSIFNETMASK
:
1850 #ifdef CONFIG_PROC_FS
1852 static void *ax25_info_start(struct seq_file
*seq
, loff_t
*pos
)
1854 struct ax25_cb
*ax25
;
1855 struct hlist_node
*node
;
1858 spin_lock_bh(&ax25_list_lock
);
1859 ax25_for_each(ax25
, node
, &ax25_list
) {
1867 static void *ax25_info_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1871 return hlist_entry( ((struct ax25_cb
*)v
)->ax25_node
.next
,
1872 struct ax25_cb
, ax25_node
);
1875 static void ax25_info_stop(struct seq_file
*seq
, void *v
)
1877 spin_unlock_bh(&ax25_list_lock
);
1880 static int ax25_info_show(struct seq_file
*seq
, void *v
)
1889 * 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
1892 seq_printf(seq
, "%8.8lx %s %s%s ",
1894 ax25
->ax25_dev
== NULL
? "???" : ax25
->ax25_dev
->dev
->name
,
1895 ax2asc(buf
, &ax25
->source_addr
),
1896 ax25
->iamdigi
? "*":"");
1897 seq_printf(seq
, "%s", ax2asc(buf
, &ax25
->dest_addr
));
1899 for (k
=0; (ax25
->digipeat
!= NULL
) && (k
< ax25
->digipeat
->ndigi
); k
++) {
1900 seq_printf(seq
, ",%s%s",
1901 ax2asc(buf
, &ax25
->digipeat
->calls
[k
]),
1902 ax25
->digipeat
->repeated
[k
]? "*":"");
1905 seq_printf(seq
, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1907 ax25
->vs
, ax25
->vr
, ax25
->va
,
1908 ax25_display_timer(&ax25
->t1timer
) / HZ
, ax25
->t1
/ HZ
,
1909 ax25_display_timer(&ax25
->t2timer
) / HZ
, ax25
->t2
/ HZ
,
1910 ax25_display_timer(&ax25
->t3timer
) / HZ
, ax25
->t3
/ HZ
,
1911 ax25_display_timer(&ax25
->idletimer
) / (60 * HZ
),
1912 ax25
->idle
/ (60 * HZ
),
1913 ax25
->n2count
, ax25
->n2
,
1918 if (ax25
->sk
!= NULL
) {
1919 bh_lock_sock(ax25
->sk
);
1920 seq_printf(seq
," %d %d %ld\n",
1921 atomic_read(&ax25
->sk
->sk_wmem_alloc
),
1922 atomic_read(&ax25
->sk
->sk_rmem_alloc
),
1923 ax25
->sk
->sk_socket
!= NULL
? SOCK_INODE(ax25
->sk
->sk_socket
)->i_ino
: 0L);
1924 bh_unlock_sock(ax25
->sk
);
1926 seq_puts(seq
, " * * *\n");
1931 static struct seq_operations ax25_info_seqops
= {
1932 .start
= ax25_info_start
,
1933 .next
= ax25_info_next
,
1934 .stop
= ax25_info_stop
,
1935 .show
= ax25_info_show
,
1938 static int ax25_info_open(struct inode
*inode
, struct file
*file
)
1940 return seq_open(file
, &ax25_info_seqops
);
1943 static struct file_operations ax25_info_fops
= {
1944 .owner
= THIS_MODULE
,
1945 .open
= ax25_info_open
,
1947 .llseek
= seq_lseek
,
1948 .release
= seq_release
,
1953 static struct net_proto_family ax25_family_ops
= {
1955 .create
= ax25_create
,
1956 .owner
= THIS_MODULE
,
1959 static const struct proto_ops ax25_proto_ops
= {
1961 .owner
= THIS_MODULE
,
1962 .release
= ax25_release
,
1964 .connect
= ax25_connect
,
1965 .socketpair
= sock_no_socketpair
,
1966 .accept
= ax25_accept
,
1967 .getname
= ax25_getname
,
1968 .poll
= datagram_poll
,
1969 .ioctl
= ax25_ioctl
,
1970 .listen
= ax25_listen
,
1971 .shutdown
= ax25_shutdown
,
1972 .setsockopt
= ax25_setsockopt
,
1973 .getsockopt
= ax25_getsockopt
,
1974 .sendmsg
= ax25_sendmsg
,
1975 .recvmsg
= ax25_recvmsg
,
1976 .mmap
= sock_no_mmap
,
1977 .sendpage
= sock_no_sendpage
,
1981 * Called by socket.c on kernel start up
1983 static struct packet_type ax25_packet_type
= {
1984 .type
= __constant_htons(ETH_P_AX25
),
1985 .dev
= NULL
, /* All devices */
1986 .func
= ax25_kiss_rcv
,
1989 static struct notifier_block ax25_dev_notifier
= {
1990 .notifier_call
=ax25_device_event
,
1993 static int __init
ax25_init(void)
1995 int rc
= proto_register(&ax25_proto
, 0);
2000 sock_register(&ax25_family_ops
);
2001 dev_add_pack(&ax25_packet_type
);
2002 register_netdevice_notifier(&ax25_dev_notifier
);
2003 ax25_register_sysctl();
2005 proc_net_fops_create("ax25_route", S_IRUGO
, &ax25_route_fops
);
2006 proc_net_fops_create("ax25", S_IRUGO
, &ax25_info_fops
);
2007 proc_net_fops_create("ax25_calls", S_IRUGO
, &ax25_uid_fops
);
2011 module_init(ax25_init
);
2014 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2015 MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2016 MODULE_LICENSE("GPL");
2017 MODULE_ALIAS_NETPROTO(PF_AX25
);
2019 static void __exit
ax25_exit(void)
2021 proc_net_remove("ax25_route");
2022 proc_net_remove("ax25");
2023 proc_net_remove("ax25_calls");
2028 ax25_unregister_sysctl();
2029 unregister_netdevice_notifier(&ax25_dev_notifier
);
2031 dev_remove_pack(&ax25_packet_type
);
2033 sock_unregister(PF_AX25
);
2034 proto_unregister(&ax25_proto
);
2036 module_exit(ax25_exit
);