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) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
8 * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
9 * Copyright (C) Terry Dawson VK2KTJ (terry@animats.net)
10 * Copyright (C) Tomi Manninen OH2BNS (oh2bns@sral.fi)
13 #include <linux/capability.h>
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/init.h>
17 #include <linux/errno.h>
18 #include <linux/types.h>
19 #include <linux/socket.h>
21 #include <linux/kernel.h>
22 #include <linux/sched.h>
23 #include <linux/spinlock.h>
24 #include <linux/timer.h>
25 #include <linux/string.h>
26 #include <linux/sockios.h>
27 #include <linux/net.h>
28 #include <linux/stat.h>
29 #include <net/net_namespace.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/system.h>
37 #include <asm/uaccess.h>
38 #include <linux/fcntl.h>
39 #include <linux/termios.h>
41 #include <linux/interrupt.h>
42 #include <linux/notifier.h>
44 #include <linux/proc_fs.h>
45 #include <linux/seq_file.h>
46 #include <net/tcp_states.h>
50 static int rose_ndevs
= 10;
52 int sysctl_rose_restart_request_timeout
= ROSE_DEFAULT_T0
;
53 int sysctl_rose_call_request_timeout
= ROSE_DEFAULT_T1
;
54 int sysctl_rose_reset_request_timeout
= ROSE_DEFAULT_T2
;
55 int sysctl_rose_clear_request_timeout
= ROSE_DEFAULT_T3
;
56 int sysctl_rose_no_activity_timeout
= ROSE_DEFAULT_IDLE
;
57 int sysctl_rose_ack_hold_back_timeout
= ROSE_DEFAULT_HB
;
58 int sysctl_rose_routing_control
= ROSE_DEFAULT_ROUTING
;
59 int sysctl_rose_link_fail_timeout
= ROSE_DEFAULT_FAIL_TIMEOUT
;
60 int sysctl_rose_maximum_vcs
= ROSE_DEFAULT_MAXVC
;
61 int sysctl_rose_window_size
= ROSE_DEFAULT_WINDOW_SIZE
;
63 static HLIST_HEAD(rose_list
);
64 static DEFINE_SPINLOCK(rose_list_lock
);
66 static const struct proto_ops rose_proto_ops
;
68 ax25_address rose_callsign
;
71 * ROSE network devices are virtual network devices encapsulating ROSE
72 * frames into AX.25 which will be sent through an AX.25 device, so form a
73 * special "super class" of normal net devices; split their locks off into a
74 * separate class since they always nest.
76 static struct lock_class_key rose_netdev_xmit_lock_key
;
77 static struct lock_class_key rose_netdev_addr_lock_key
;
79 static void rose_set_lockdep_one(struct net_device
*dev
,
80 struct netdev_queue
*txq
,
83 lockdep_set_class(&txq
->_xmit_lock
, &rose_netdev_xmit_lock_key
);
86 static void rose_set_lockdep_key(struct net_device
*dev
)
88 lockdep_set_class(&dev
->addr_list_lock
, &rose_netdev_addr_lock_key
);
89 netdev_for_each_tx_queue(dev
, rose_set_lockdep_one
, NULL
);
93 * Convert a ROSE address into text.
95 char *rose2asc(char *buf
, const rose_address
*addr
)
97 if (addr
->rose_addr
[0] == 0x00 && addr
->rose_addr
[1] == 0x00 &&
98 addr
->rose_addr
[2] == 0x00 && addr
->rose_addr
[3] == 0x00 &&
99 addr
->rose_addr
[4] == 0x00) {
102 sprintf(buf
, "%02X%02X%02X%02X%02X", addr
->rose_addr
[0] & 0xFF,
103 addr
->rose_addr
[1] & 0xFF,
104 addr
->rose_addr
[2] & 0xFF,
105 addr
->rose_addr
[3] & 0xFF,
106 addr
->rose_addr
[4] & 0xFF);
113 * Compare two ROSE addresses, 0 == equal.
115 int rosecmp(rose_address
*addr1
, rose_address
*addr2
)
119 for (i
= 0; i
< 5; i
++)
120 if (addr1
->rose_addr
[i
] != addr2
->rose_addr
[i
])
127 * Compare two ROSE addresses for only mask digits, 0 == equal.
129 int rosecmpm(rose_address
*addr1
, rose_address
*addr2
, unsigned short mask
)
136 for (i
= 0; i
< mask
; i
++) {
140 if ((addr1
->rose_addr
[j
] & 0x0F) != (addr2
->rose_addr
[j
] & 0x0F))
143 if ((addr1
->rose_addr
[j
] & 0xF0) != (addr2
->rose_addr
[j
] & 0xF0))
152 * Socket removal during an interrupt is now safe.
154 static void rose_remove_socket(struct sock
*sk
)
156 spin_lock_bh(&rose_list_lock
);
157 sk_del_node_init(sk
);
158 spin_unlock_bh(&rose_list_lock
);
162 * Kill all bound sockets on a broken link layer connection to a
163 * particular neighbour.
165 void rose_kill_by_neigh(struct rose_neigh
*neigh
)
168 struct hlist_node
*node
;
170 spin_lock_bh(&rose_list_lock
);
171 sk_for_each(s
, node
, &rose_list
) {
172 struct rose_sock
*rose
= rose_sk(s
);
174 if (rose
->neighbour
== neigh
) {
175 rose_disconnect(s
, ENETUNREACH
, ROSE_OUT_OF_ORDER
, 0);
176 rose
->neighbour
->use
--;
177 rose
->neighbour
= NULL
;
180 spin_unlock_bh(&rose_list_lock
);
184 * Kill all bound sockets on a dropped device.
186 static void rose_kill_by_device(struct net_device
*dev
)
189 struct hlist_node
*node
;
191 spin_lock_bh(&rose_list_lock
);
192 sk_for_each(s
, node
, &rose_list
) {
193 struct rose_sock
*rose
= rose_sk(s
);
195 if (rose
->device
== dev
) {
196 rose_disconnect(s
, ENETUNREACH
, ROSE_OUT_OF_ORDER
, 0);
197 rose
->neighbour
->use
--;
201 spin_unlock_bh(&rose_list_lock
);
205 * Handle device status changes.
207 static int rose_device_event(struct notifier_block
*this, unsigned long event
,
210 struct net_device
*dev
= (struct net_device
*)ptr
;
212 if (!net_eq(dev_net(dev
), &init_net
))
215 if (event
!= NETDEV_DOWN
)
220 rose_kill_by_device(dev
);
223 rose_link_device_down(dev
);
224 rose_rt_device_down(dev
);
232 * Add a socket to the bound sockets list.
234 static void rose_insert_socket(struct sock
*sk
)
237 spin_lock_bh(&rose_list_lock
);
238 sk_add_node(sk
, &rose_list
);
239 spin_unlock_bh(&rose_list_lock
);
243 * Find a socket that wants to accept the Call Request we just
246 static struct sock
*rose_find_listener(rose_address
*addr
, ax25_address
*call
)
249 struct hlist_node
*node
;
251 spin_lock_bh(&rose_list_lock
);
252 sk_for_each(s
, node
, &rose_list
) {
253 struct rose_sock
*rose
= rose_sk(s
);
255 if (!rosecmp(&rose
->source_addr
, addr
) &&
256 !ax25cmp(&rose
->source_call
, call
) &&
257 !rose
->source_ndigis
&& s
->sk_state
== TCP_LISTEN
)
261 sk_for_each(s
, node
, &rose_list
) {
262 struct rose_sock
*rose
= rose_sk(s
);
264 if (!rosecmp(&rose
->source_addr
, addr
) &&
265 !ax25cmp(&rose
->source_call
, &null_ax25_address
) &&
266 s
->sk_state
== TCP_LISTEN
)
271 spin_unlock_bh(&rose_list_lock
);
276 * Find a connected ROSE socket given my LCI and device.
278 struct sock
*rose_find_socket(unsigned int lci
, struct rose_neigh
*neigh
)
281 struct hlist_node
*node
;
283 spin_lock_bh(&rose_list_lock
);
284 sk_for_each(s
, node
, &rose_list
) {
285 struct rose_sock
*rose
= rose_sk(s
);
287 if (rose
->lci
== lci
&& rose
->neighbour
== neigh
)
292 spin_unlock_bh(&rose_list_lock
);
297 * Find a unique LCI for a given device.
299 unsigned int rose_new_lci(struct rose_neigh
*neigh
)
303 if (neigh
->dce_mode
) {
304 for (lci
= 1; lci
<= sysctl_rose_maximum_vcs
; lci
++)
305 if (rose_find_socket(lci
, neigh
) == NULL
&& rose_route_free_lci(lci
, neigh
) == NULL
)
308 for (lci
= sysctl_rose_maximum_vcs
; lci
> 0; lci
--)
309 if (rose_find_socket(lci
, neigh
) == NULL
&& rose_route_free_lci(lci
, neigh
) == NULL
)
319 void rose_destroy_socket(struct sock
*);
322 * Handler for deferred kills.
324 static void rose_destroy_timer(unsigned long data
)
326 rose_destroy_socket((struct sock
*)data
);
330 * This is called from user mode and the timers. Thus it protects itself
331 * against interrupt users but doesn't worry about being called during
332 * work. Once it is removed from the queue no interrupt or bottom half
333 * will touch it and we are (fairly 8-) ) safe.
335 void rose_destroy_socket(struct sock
*sk
)
339 rose_remove_socket(sk
);
340 rose_stop_heartbeat(sk
);
341 rose_stop_idletimer(sk
);
344 rose_clear_queues(sk
); /* Flush the queues */
346 while ((skb
= skb_dequeue(&sk
->sk_receive_queue
)) != NULL
) {
347 if (skb
->sk
!= sk
) { /* A pending connection */
348 /* Queue the unaccepted socket for death */
349 sock_set_flag(skb
->sk
, SOCK_DEAD
);
350 rose_start_heartbeat(skb
->sk
);
351 rose_sk(skb
->sk
)->state
= ROSE_STATE_0
;
357 if (sk_has_allocations(sk
)) {
358 /* Defer: outstanding buffers */
359 setup_timer(&sk
->sk_timer
, rose_destroy_timer
,
361 sk
->sk_timer
.expires
= jiffies
+ 10 * HZ
;
362 add_timer(&sk
->sk_timer
);
368 * Handling for system calls applied via the various interfaces to a
369 * ROSE socket object.
372 static int rose_setsockopt(struct socket
*sock
, int level
, int optname
,
373 char __user
*optval
, unsigned int optlen
)
375 struct sock
*sk
= sock
->sk
;
376 struct rose_sock
*rose
= rose_sk(sk
);
379 if (level
!= SOL_ROSE
)
382 if (optlen
< sizeof(int))
385 if (get_user(opt
, (int __user
*)optval
))
390 rose
->defer
= opt
? 1 : 0;
420 rose
->idle
= opt
* 60 * HZ
;
424 rose
->qbitincl
= opt
? 1 : 0;
432 static int rose_getsockopt(struct socket
*sock
, int level
, int optname
,
433 char __user
*optval
, int __user
*optlen
)
435 struct sock
*sk
= sock
->sk
;
436 struct rose_sock
*rose
= rose_sk(sk
);
440 if (level
!= SOL_ROSE
)
443 if (get_user(len
, optlen
))
471 val
= rose
->idle
/ (60 * HZ
);
475 val
= rose
->qbitincl
;
482 len
= min_t(unsigned int, len
, sizeof(int));
484 if (put_user(len
, optlen
))
487 return copy_to_user(optval
, &val
, len
) ? -EFAULT
: 0;
490 static int rose_listen(struct socket
*sock
, int backlog
)
492 struct sock
*sk
= sock
->sk
;
494 if (sk
->sk_state
!= TCP_LISTEN
) {
495 struct rose_sock
*rose
= rose_sk(sk
);
497 rose
->dest_ndigis
= 0;
498 memset(&rose
->dest_addr
, 0, ROSE_ADDR_LEN
);
499 memset(&rose
->dest_call
, 0, AX25_ADDR_LEN
);
500 memset(rose
->dest_digis
, 0, AX25_ADDR_LEN
* ROSE_MAX_DIGIS
);
501 sk
->sk_max_ack_backlog
= backlog
;
502 sk
->sk_state
= TCP_LISTEN
;
509 static struct proto rose_proto
= {
511 .owner
= THIS_MODULE
,
512 .obj_size
= sizeof(struct rose_sock
),
515 static int rose_create(struct net
*net
, struct socket
*sock
, int protocol
,
519 struct rose_sock
*rose
;
521 if (!net_eq(net
, &init_net
))
522 return -EAFNOSUPPORT
;
524 if (sock
->type
!= SOCK_SEQPACKET
|| protocol
!= 0)
525 return -ESOCKTNOSUPPORT
;
527 sk
= sk_alloc(net
, PF_ROSE
, GFP_ATOMIC
, &rose_proto
);
533 sock_init_data(sock
, sk
);
535 skb_queue_head_init(&rose
->ack_queue
);
537 skb_queue_head_init(&rose
->frag_queue
);
541 sock
->ops
= &rose_proto_ops
;
542 sk
->sk_protocol
= protocol
;
544 init_timer(&rose
->timer
);
545 init_timer(&rose
->idletimer
);
547 rose
->t1
= msecs_to_jiffies(sysctl_rose_call_request_timeout
);
548 rose
->t2
= msecs_to_jiffies(sysctl_rose_reset_request_timeout
);
549 rose
->t3
= msecs_to_jiffies(sysctl_rose_clear_request_timeout
);
550 rose
->hb
= msecs_to_jiffies(sysctl_rose_ack_hold_back_timeout
);
551 rose
->idle
= msecs_to_jiffies(sysctl_rose_no_activity_timeout
);
553 rose
->state
= ROSE_STATE_0
;
558 static struct sock
*rose_make_new(struct sock
*osk
)
561 struct rose_sock
*rose
, *orose
;
563 if (osk
->sk_type
!= SOCK_SEQPACKET
)
566 sk
= sk_alloc(sock_net(osk
), PF_ROSE
, GFP_ATOMIC
, &rose_proto
);
572 sock_init_data(NULL
, sk
);
574 skb_queue_head_init(&rose
->ack_queue
);
576 skb_queue_head_init(&rose
->frag_queue
);
580 sk
->sk_type
= osk
->sk_type
;
581 sk
->sk_priority
= osk
->sk_priority
;
582 sk
->sk_protocol
= osk
->sk_protocol
;
583 sk
->sk_rcvbuf
= osk
->sk_rcvbuf
;
584 sk
->sk_sndbuf
= osk
->sk_sndbuf
;
585 sk
->sk_state
= TCP_ESTABLISHED
;
586 sock_copy_flags(sk
, osk
);
588 init_timer(&rose
->timer
);
589 init_timer(&rose
->idletimer
);
591 orose
= rose_sk(osk
);
592 rose
->t1
= orose
->t1
;
593 rose
->t2
= orose
->t2
;
594 rose
->t3
= orose
->t3
;
595 rose
->hb
= orose
->hb
;
596 rose
->idle
= orose
->idle
;
597 rose
->defer
= orose
->defer
;
598 rose
->device
= orose
->device
;
599 rose
->qbitincl
= orose
->qbitincl
;
604 static int rose_release(struct socket
*sock
)
606 struct sock
*sk
= sock
->sk
;
607 struct rose_sock
*rose
;
609 if (sk
== NULL
) return 0;
616 switch (rose
->state
) {
619 rose_disconnect(sk
, 0, -1, -1);
621 rose_destroy_socket(sk
);
625 rose
->neighbour
->use
--;
627 rose_disconnect(sk
, 0, -1, -1);
629 rose_destroy_socket(sk
);
636 rose_clear_queues(sk
);
637 rose_stop_idletimer(sk
);
638 rose_write_internal(sk
, ROSE_CLEAR_REQUEST
);
639 rose_start_t3timer(sk
);
640 rose
->state
= ROSE_STATE_2
;
641 sk
->sk_state
= TCP_CLOSE
;
642 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
643 sk
->sk_state_change(sk
);
644 sock_set_flag(sk
, SOCK_DEAD
);
645 sock_set_flag(sk
, SOCK_DESTROY
);
659 static int rose_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
661 struct sock
*sk
= sock
->sk
;
662 struct rose_sock
*rose
= rose_sk(sk
);
663 struct sockaddr_rose
*addr
= (struct sockaddr_rose
*)uaddr
;
664 struct net_device
*dev
;
665 ax25_address
*source
;
666 ax25_uid_assoc
*user
;
669 if (!sock_flag(sk
, SOCK_ZAPPED
))
672 if (addr_len
!= sizeof(struct sockaddr_rose
) && addr_len
!= sizeof(struct full_sockaddr_rose
))
675 if (addr
->srose_family
!= AF_ROSE
)
678 if (addr_len
== sizeof(struct sockaddr_rose
) && addr
->srose_ndigis
> 1)
681 if (addr
->srose_ndigis
> ROSE_MAX_DIGIS
)
684 if ((dev
= rose_dev_get(&addr
->srose_addr
)) == NULL
) {
685 SOCK_DEBUG(sk
, "ROSE: bind failed: invalid address\n");
686 return -EADDRNOTAVAIL
;
689 source
= &addr
->srose_call
;
691 user
= ax25_findbyuid(current_euid());
693 rose
->source_call
= user
->call
;
696 if (ax25_uid_policy
&& !capable(CAP_NET_BIND_SERVICE
))
698 rose
->source_call
= *source
;
701 rose
->source_addr
= addr
->srose_addr
;
703 rose
->source_ndigis
= addr
->srose_ndigis
;
705 if (addr_len
== sizeof(struct full_sockaddr_rose
)) {
706 struct full_sockaddr_rose
*full_addr
= (struct full_sockaddr_rose
*)uaddr
;
707 for (n
= 0 ; n
< addr
->srose_ndigis
; n
++)
708 rose
->source_digis
[n
] = full_addr
->srose_digis
[n
];
710 if (rose
->source_ndigis
== 1) {
711 rose
->source_digis
[0] = addr
->srose_digi
;
715 rose_insert_socket(sk
);
717 sock_reset_flag(sk
, SOCK_ZAPPED
);
718 SOCK_DEBUG(sk
, "ROSE: socket is bound\n");
722 static int rose_connect(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
, int flags
)
724 struct sock
*sk
= sock
->sk
;
725 struct rose_sock
*rose
= rose_sk(sk
);
726 struct sockaddr_rose
*addr
= (struct sockaddr_rose
*)uaddr
;
727 unsigned char cause
, diagnostic
;
728 struct net_device
*dev
;
729 ax25_uid_assoc
*user
;
732 if (addr_len
!= sizeof(struct sockaddr_rose
) && addr_len
!= sizeof(struct full_sockaddr_rose
))
735 if (addr
->srose_family
!= AF_ROSE
)
738 if (addr_len
== sizeof(struct sockaddr_rose
) && addr
->srose_ndigis
> 1)
741 if (addr
->srose_ndigis
> ROSE_MAX_DIGIS
)
744 /* Source + Destination digis should not exceed ROSE_MAX_DIGIS */
745 if ((rose
->source_ndigis
+ addr
->srose_ndigis
) > ROSE_MAX_DIGIS
)
750 if (sk
->sk_state
== TCP_ESTABLISHED
&& sock
->state
== SS_CONNECTING
) {
751 /* Connect completed during a ERESTARTSYS event */
752 sock
->state
= SS_CONNECTED
;
756 if (sk
->sk_state
== TCP_CLOSE
&& sock
->state
== SS_CONNECTING
) {
757 sock
->state
= SS_UNCONNECTED
;
762 if (sk
->sk_state
== TCP_ESTABLISHED
) {
763 /* No reconnect on a seqpacket socket */
768 sk
->sk_state
= TCP_CLOSE
;
769 sock
->state
= SS_UNCONNECTED
;
771 rose
->neighbour
= rose_get_neigh(&addr
->srose_addr
, &cause
,
773 if (!rose
->neighbour
) {
778 rose
->lci
= rose_new_lci(rose
->neighbour
);
784 if (sock_flag(sk
, SOCK_ZAPPED
)) { /* Must bind first - autobinding in this may or may not work */
785 sock_reset_flag(sk
, SOCK_ZAPPED
);
787 if ((dev
= rose_dev_first()) == NULL
) {
792 user
= ax25_findbyuid(current_euid());
798 memcpy(&rose
->source_addr
, dev
->dev_addr
, ROSE_ADDR_LEN
);
799 rose
->source_call
= user
->call
;
803 rose_insert_socket(sk
); /* Finish the bind */
806 rose
->dest_addr
= addr
->srose_addr
;
807 rose
->dest_call
= addr
->srose_call
;
808 rose
->rand
= ((long)rose
& 0xFFFF) + rose
->lci
;
809 rose
->dest_ndigis
= addr
->srose_ndigis
;
811 if (addr_len
== sizeof(struct full_sockaddr_rose
)) {
812 struct full_sockaddr_rose
*full_addr
= (struct full_sockaddr_rose
*)uaddr
;
813 for (n
= 0 ; n
< addr
->srose_ndigis
; n
++)
814 rose
->dest_digis
[n
] = full_addr
->srose_digis
[n
];
816 if (rose
->dest_ndigis
== 1) {
817 rose
->dest_digis
[0] = addr
->srose_digi
;
821 /* Move to connecting socket, start sending Connect Requests */
822 sock
->state
= SS_CONNECTING
;
823 sk
->sk_state
= TCP_SYN_SENT
;
825 rose
->state
= ROSE_STATE_1
;
827 rose
->neighbour
->use
++;
829 rose_write_internal(sk
, ROSE_CALL_REQUEST
);
830 rose_start_heartbeat(sk
);
831 rose_start_t1timer(sk
);
834 if (sk
->sk_state
!= TCP_ESTABLISHED
&& (flags
& O_NONBLOCK
)) {
840 * A Connect Ack with Choke or timeout or failed routing will go to
843 if (sk
->sk_state
== TCP_SYN_SENT
) {
847 prepare_to_wait(sk
->sk_sleep
, &wait
,
849 if (sk
->sk_state
!= TCP_SYN_SENT
)
851 if (!signal_pending(current
)) {
860 finish_wait(sk
->sk_sleep
, &wait
);
866 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
867 /* Try next neighbour */
868 rose
->neighbour
= rose_get_neigh(&addr
->srose_addr
, &cause
, &diagnostic
, 0);
870 goto rose_try_next_neigh
;
872 /* No more neighbours */
873 sock
->state
= SS_UNCONNECTED
;
874 err
= sock_error(sk
); /* Always set at this point */
878 sock
->state
= SS_CONNECTED
;
886 static int rose_accept(struct socket
*sock
, struct socket
*newsock
, int flags
)
894 if ((sk
= sock
->sk
) == NULL
)
898 if (sk
->sk_type
!= SOCK_SEQPACKET
) {
903 if (sk
->sk_state
!= TCP_LISTEN
) {
909 * The write queue this time is holding sockets ready to use
910 * hooked into the SABM we saved
913 prepare_to_wait(sk
->sk_sleep
, &wait
, TASK_INTERRUPTIBLE
);
915 skb
= skb_dequeue(&sk
->sk_receive_queue
);
919 if (flags
& O_NONBLOCK
) {
923 if (!signal_pending(current
)) {
932 finish_wait(sk
->sk_sleep
, &wait
);
937 sock_graft(newsk
, newsock
);
939 /* Now attach up the new socket */
942 sk
->sk_ack_backlog
--;
950 static int rose_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
951 int *uaddr_len
, int peer
)
953 struct full_sockaddr_rose
*srose
= (struct full_sockaddr_rose
*)uaddr
;
954 struct sock
*sk
= sock
->sk
;
955 struct rose_sock
*rose
= rose_sk(sk
);
958 memset(srose
, 0, sizeof(*srose
));
960 if (sk
->sk_state
!= TCP_ESTABLISHED
)
962 srose
->srose_family
= AF_ROSE
;
963 srose
->srose_addr
= rose
->dest_addr
;
964 srose
->srose_call
= rose
->dest_call
;
965 srose
->srose_ndigis
= rose
->dest_ndigis
;
966 for (n
= 0; n
< rose
->dest_ndigis
; n
++)
967 srose
->srose_digis
[n
] = rose
->dest_digis
[n
];
969 srose
->srose_family
= AF_ROSE
;
970 srose
->srose_addr
= rose
->source_addr
;
971 srose
->srose_call
= rose
->source_call
;
972 srose
->srose_ndigis
= rose
->source_ndigis
;
973 for (n
= 0; n
< rose
->source_ndigis
; n
++)
974 srose
->srose_digis
[n
] = rose
->source_digis
[n
];
977 *uaddr_len
= sizeof(struct full_sockaddr_rose
);
981 int rose_rx_call_request(struct sk_buff
*skb
, struct net_device
*dev
, struct rose_neigh
*neigh
, unsigned int lci
)
985 struct rose_sock
*make_rose
;
986 struct rose_facilities_struct facilities
;
989 skb
->sk
= NULL
; /* Initially we don't know who it's for */
992 * skb->data points to the rose frame start
994 memset(&facilities
, 0x00, sizeof(struct rose_facilities_struct
));
996 len
= (((skb
->data
[3] >> 4) & 0x0F) + 1) >> 1;
997 len
+= (((skb
->data
[3] >> 0) & 0x0F) + 1) >> 1;
998 if (!rose_parse_facilities(skb
->data
+ len
+ 4, &facilities
)) {
999 rose_transmit_clear_request(neigh
, lci
, ROSE_INVALID_FACILITY
, 76);
1003 sk
= rose_find_listener(&facilities
.source_addr
, &facilities
.source_call
);
1006 * We can't accept the Call Request.
1008 if (sk
== NULL
|| sk_acceptq_is_full(sk
) ||
1009 (make
= rose_make_new(sk
)) == NULL
) {
1010 rose_transmit_clear_request(neigh
, lci
, ROSE_NETWORK_CONGESTION
, 120);
1015 make
->sk_state
= TCP_ESTABLISHED
;
1016 make_rose
= rose_sk(make
);
1018 make_rose
->lci
= lci
;
1019 make_rose
->dest_addr
= facilities
.dest_addr
;
1020 make_rose
->dest_call
= facilities
.dest_call
;
1021 make_rose
->dest_ndigis
= facilities
.dest_ndigis
;
1022 for (n
= 0 ; n
< facilities
.dest_ndigis
; n
++)
1023 make_rose
->dest_digis
[n
] = facilities
.dest_digis
[n
];
1024 make_rose
->source_addr
= facilities
.source_addr
;
1025 make_rose
->source_call
= facilities
.source_call
;
1026 make_rose
->source_ndigis
= facilities
.source_ndigis
;
1027 for (n
= 0 ; n
< facilities
.source_ndigis
; n
++)
1028 make_rose
->source_digis
[n
]= facilities
.source_digis
[n
];
1029 make_rose
->neighbour
= neigh
;
1030 make_rose
->device
= dev
;
1031 make_rose
->facilities
= facilities
;
1033 make_rose
->neighbour
->use
++;
1035 if (rose_sk(sk
)->defer
) {
1036 make_rose
->state
= ROSE_STATE_5
;
1038 rose_write_internal(make
, ROSE_CALL_ACCEPTED
);
1039 make_rose
->state
= ROSE_STATE_3
;
1040 rose_start_idletimer(make
);
1043 make_rose
->condition
= 0x00;
1048 sk
->sk_ack_backlog
++;
1050 rose_insert_socket(make
);
1052 skb_queue_head(&sk
->sk_receive_queue
, skb
);
1054 rose_start_heartbeat(make
);
1056 if (!sock_flag(sk
, SOCK_DEAD
))
1057 sk
->sk_data_ready(sk
, skb
->len
);
1062 static int rose_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
1063 struct msghdr
*msg
, size_t len
)
1065 struct sock
*sk
= sock
->sk
;
1066 struct rose_sock
*rose
= rose_sk(sk
);
1067 struct sockaddr_rose
*usrose
= (struct sockaddr_rose
*)msg
->msg_name
;
1069 struct full_sockaddr_rose srose
;
1070 struct sk_buff
*skb
;
1071 unsigned char *asmptr
;
1072 int n
, size
, qbit
= 0;
1074 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_EOR
|MSG_CMSG_COMPAT
))
1077 if (sock_flag(sk
, SOCK_ZAPPED
))
1078 return -EADDRNOTAVAIL
;
1080 if (sk
->sk_shutdown
& SEND_SHUTDOWN
) {
1081 send_sig(SIGPIPE
, current
, 0);
1085 if (rose
->neighbour
== NULL
|| rose
->device
== NULL
)
1086 return -ENETUNREACH
;
1088 if (usrose
!= NULL
) {
1089 if (msg
->msg_namelen
!= sizeof(struct sockaddr_rose
) && msg
->msg_namelen
!= sizeof(struct full_sockaddr_rose
))
1091 memset(&srose
, 0, sizeof(struct full_sockaddr_rose
));
1092 memcpy(&srose
, usrose
, msg
->msg_namelen
);
1093 if (rosecmp(&rose
->dest_addr
, &srose
.srose_addr
) != 0 ||
1094 ax25cmp(&rose
->dest_call
, &srose
.srose_call
) != 0)
1096 if (srose
.srose_ndigis
!= rose
->dest_ndigis
)
1098 if (srose
.srose_ndigis
== rose
->dest_ndigis
) {
1099 for (n
= 0 ; n
< srose
.srose_ndigis
; n
++)
1100 if (ax25cmp(&rose
->dest_digis
[n
],
1101 &srose
.srose_digis
[n
]))
1104 if (srose
.srose_family
!= AF_ROSE
)
1107 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1110 srose
.srose_family
= AF_ROSE
;
1111 srose
.srose_addr
= rose
->dest_addr
;
1112 srose
.srose_call
= rose
->dest_call
;
1113 srose
.srose_ndigis
= rose
->dest_ndigis
;
1114 for (n
= 0 ; n
< rose
->dest_ndigis
; n
++)
1115 srose
.srose_digis
[n
] = rose
->dest_digis
[n
];
1118 SOCK_DEBUG(sk
, "ROSE: sendto: Addresses built.\n");
1120 /* Build a packet */
1121 SOCK_DEBUG(sk
, "ROSE: sendto: building packet.\n");
1122 /* Sanity check the packet size */
1126 size
= len
+ AX25_BPQ_HEADER_LEN
+ AX25_MAX_HEADER_LEN
+ ROSE_MIN_LEN
;
1128 if ((skb
= sock_alloc_send_skb(sk
, size
, msg
->msg_flags
& MSG_DONTWAIT
, &err
)) == NULL
)
1131 skb_reserve(skb
, AX25_BPQ_HEADER_LEN
+ AX25_MAX_HEADER_LEN
+ ROSE_MIN_LEN
);
1134 * Put the data on the end
1136 SOCK_DEBUG(sk
, "ROSE: Appending user data\n");
1138 skb_reset_transport_header(skb
);
1141 err
= memcpy_fromiovec(skb_transport_header(skb
), msg
->msg_iov
, len
);
1148 * If the Q BIT Include socket option is in force, the first
1149 * byte of the user data is the logical value of the Q Bit.
1151 if (rose
->qbitincl
) {
1152 qbit
= skb
->data
[0];
1157 * Push down the ROSE header
1159 asmptr
= skb_push(skb
, ROSE_MIN_LEN
);
1161 SOCK_DEBUG(sk
, "ROSE: Building Network Header.\n");
1163 /* Build a ROSE Network header */
1164 asmptr
[0] = ((rose
->lci
>> 8) & 0x0F) | ROSE_GFI
;
1165 asmptr
[1] = (rose
->lci
>> 0) & 0xFF;
1166 asmptr
[2] = ROSE_DATA
;
1169 asmptr
[0] |= ROSE_Q_BIT
;
1171 SOCK_DEBUG(sk
, "ROSE: Built header.\n");
1173 SOCK_DEBUG(sk
, "ROSE: Transmitting buffer\n");
1175 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
1181 #define ROSE_PACLEN (256-ROSE_MIN_LEN)
1182 if (skb
->len
- ROSE_MIN_LEN
> ROSE_PACLEN
) {
1183 unsigned char header
[ROSE_MIN_LEN
];
1184 struct sk_buff
*skbn
;
1188 /* Save a copy of the Header */
1189 skb_copy_from_linear_data(skb
, header
, ROSE_MIN_LEN
);
1190 skb_pull(skb
, ROSE_MIN_LEN
);
1192 frontlen
= skb_headroom(skb
);
1194 while (skb
->len
> 0) {
1195 if ((skbn
= sock_alloc_send_skb(sk
, frontlen
+ ROSE_PACLEN
, 0, &err
)) == NULL
) {
1204 skb_reserve(skbn
, frontlen
);
1206 lg
= (ROSE_PACLEN
> skb
->len
) ? skb
->len
: ROSE_PACLEN
;
1208 /* Copy the user data */
1209 skb_copy_from_linear_data(skb
, skb_put(skbn
, lg
), lg
);
1212 /* Duplicate the Header */
1213 skb_push(skbn
, ROSE_MIN_LEN
);
1214 skb_copy_to_linear_data(skbn
, header
, ROSE_MIN_LEN
);
1217 skbn
->data
[2] |= M_BIT
;
1219 skb_queue_tail(&sk
->sk_write_queue
, skbn
); /* Throw it on the queue */
1225 skb_queue_tail(&sk
->sk_write_queue
, skb
); /* Throw it on the queue */
1228 skb_queue_tail(&sk
->sk_write_queue
, skb
); /* Shove it onto the queue */
1237 static int rose_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
1238 struct msghdr
*msg
, size_t size
, int flags
)
1240 struct sock
*sk
= sock
->sk
;
1241 struct rose_sock
*rose
= rose_sk(sk
);
1242 struct sockaddr_rose
*srose
= (struct sockaddr_rose
*)msg
->msg_name
;
1244 unsigned char *asmptr
;
1245 struct sk_buff
*skb
;
1249 * This works for seqpacket too. The receiver has ordered the queue for
1250 * us! We do one quick check first though
1252 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1255 /* Now we can treat all alike */
1256 if ((skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
, flags
& MSG_DONTWAIT
, &er
)) == NULL
)
1259 qbit
= (skb
->data
[0] & ROSE_Q_BIT
) == ROSE_Q_BIT
;
1261 skb_pull(skb
, ROSE_MIN_LEN
);
1263 if (rose
->qbitincl
) {
1264 asmptr
= skb_push(skb
, 1);
1268 skb_reset_transport_header(skb
);
1271 if (copied
> size
) {
1273 msg
->msg_flags
|= MSG_TRUNC
;
1276 skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
1278 if (srose
!= NULL
) {
1279 srose
->srose_family
= AF_ROSE
;
1280 srose
->srose_addr
= rose
->dest_addr
;
1281 srose
->srose_call
= rose
->dest_call
;
1282 srose
->srose_ndigis
= rose
->dest_ndigis
;
1283 if (msg
->msg_namelen
>= sizeof(struct full_sockaddr_rose
)) {
1284 struct full_sockaddr_rose
*full_srose
= (struct full_sockaddr_rose
*)msg
->msg_name
;
1285 for (n
= 0 ; n
< rose
->dest_ndigis
; n
++)
1286 full_srose
->srose_digis
[n
] = rose
->dest_digis
[n
];
1287 msg
->msg_namelen
= sizeof(struct full_sockaddr_rose
);
1289 if (rose
->dest_ndigis
>= 1) {
1290 srose
->srose_ndigis
= 1;
1291 srose
->srose_digi
= rose
->dest_digis
[0];
1293 msg
->msg_namelen
= sizeof(struct sockaddr_rose
);
1297 skb_free_datagram(sk
, skb
);
1303 static int rose_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1305 struct sock
*sk
= sock
->sk
;
1306 struct rose_sock
*rose
= rose_sk(sk
);
1307 void __user
*argp
= (void __user
*)arg
;
1313 amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
1316 return put_user(amount
, (unsigned int __user
*) argp
);
1320 struct sk_buff
*skb
;
1322 /* These two are safe on a single CPU system as only user tasks fiddle here */
1323 if ((skb
= skb_peek(&sk
->sk_receive_queue
)) != NULL
)
1325 return put_user(amount
, (unsigned int __user
*) argp
);
1329 return sock_get_timestamp(sk
, (struct timeval __user
*) argp
);
1332 return sock_get_timestampns(sk
, (struct timespec __user
*) argp
);
1336 case SIOCGIFDSTADDR
:
1337 case SIOCSIFDSTADDR
:
1338 case SIOCGIFBRDADDR
:
1339 case SIOCSIFBRDADDR
:
1340 case SIOCGIFNETMASK
:
1341 case SIOCSIFNETMASK
:
1349 if (!capable(CAP_NET_ADMIN
))
1351 return rose_rt_ioctl(cmd
, argp
);
1353 case SIOCRSGCAUSE
: {
1354 struct rose_cause_struct rose_cause
;
1355 rose_cause
.cause
= rose
->cause
;
1356 rose_cause
.diagnostic
= rose
->diagnostic
;
1357 return copy_to_user(argp
, &rose_cause
, sizeof(struct rose_cause_struct
)) ? -EFAULT
: 0;
1360 case SIOCRSSCAUSE
: {
1361 struct rose_cause_struct rose_cause
;
1362 if (copy_from_user(&rose_cause
, argp
, sizeof(struct rose_cause_struct
)))
1364 rose
->cause
= rose_cause
.cause
;
1365 rose
->diagnostic
= rose_cause
.diagnostic
;
1370 if (!capable(CAP_NET_ADMIN
)) return -EPERM
;
1371 if (ax25cmp(&rose_callsign
, &null_ax25_address
) != 0)
1372 ax25_listen_release(&rose_callsign
, NULL
);
1373 if (copy_from_user(&rose_callsign
, argp
, sizeof(ax25_address
)))
1375 if (ax25cmp(&rose_callsign
, &null_ax25_address
) != 0)
1376 return ax25_listen_register(&rose_callsign
, NULL
);
1381 return copy_to_user(argp
, &rose_callsign
, sizeof(ax25_address
)) ? -EFAULT
: 0;
1384 if (rose
->state
== ROSE_STATE_5
) {
1385 rose_write_internal(sk
, ROSE_CALL_ACCEPTED
);
1386 rose_start_idletimer(sk
);
1387 rose
->condition
= 0x00;
1392 rose
->state
= ROSE_STATE_3
;
1397 return -ENOIOCTLCMD
;
1403 #ifdef CONFIG_PROC_FS
1404 static void *rose_info_start(struct seq_file
*seq
, loff_t
*pos
)
1405 __acquires(rose_list_lock
)
1409 struct hlist_node
*node
;
1411 spin_lock_bh(&rose_list_lock
);
1413 return SEQ_START_TOKEN
;
1416 sk_for_each(s
, node
, &rose_list
) {
1424 static void *rose_info_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1428 return (v
== SEQ_START_TOKEN
) ? sk_head(&rose_list
)
1429 : sk_next((struct sock
*)v
);
1432 static void rose_info_stop(struct seq_file
*seq
, void *v
)
1433 __releases(rose_list_lock
)
1435 spin_unlock_bh(&rose_list_lock
);
1438 static int rose_info_show(struct seq_file
*seq
, void *v
)
1440 char buf
[11], rsbuf
[11];
1442 if (v
== SEQ_START_TOKEN
)
1444 "dest_addr dest_call src_addr src_call dev lci neigh st vs vr va t t1 t2 t3 hb idle Snd-Q Rcv-Q inode\n");
1448 struct rose_sock
*rose
= rose_sk(s
);
1449 const char *devname
, *callsign
;
1450 const struct net_device
*dev
= rose
->device
;
1455 devname
= dev
->name
;
1457 seq_printf(seq
, "%-10s %-9s ",
1458 rose2asc(rsbuf
, &rose
->dest_addr
),
1459 ax2asc(buf
, &rose
->dest_call
));
1461 if (ax25cmp(&rose
->source_call
, &null_ax25_address
) == 0)
1462 callsign
= "??????-?";
1464 callsign
= ax2asc(buf
, &rose
->source_call
);
1467 "%-10s %-9s %-5s %3.3X %05d %d %d %d %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %ld\n",
1468 rose2asc(rsbuf
, &rose
->source_addr
),
1472 (rose
->neighbour
) ? rose
->neighbour
->number
: 0,
1477 ax25_display_timer(&rose
->timer
) / HZ
,
1482 ax25_display_timer(&rose
->idletimer
) / (60 * HZ
),
1483 rose
->idle
/ (60 * HZ
),
1484 sk_wmem_alloc_get(s
),
1485 sk_rmem_alloc_get(s
),
1486 s
->sk_socket
? SOCK_INODE(s
->sk_socket
)->i_ino
: 0L);
1492 static const struct seq_operations rose_info_seqops
= {
1493 .start
= rose_info_start
,
1494 .next
= rose_info_next
,
1495 .stop
= rose_info_stop
,
1496 .show
= rose_info_show
,
1499 static int rose_info_open(struct inode
*inode
, struct file
*file
)
1501 return seq_open(file
, &rose_info_seqops
);
1504 static const struct file_operations rose_info_fops
= {
1505 .owner
= THIS_MODULE
,
1506 .open
= rose_info_open
,
1508 .llseek
= seq_lseek
,
1509 .release
= seq_release
,
1511 #endif /* CONFIG_PROC_FS */
1513 static const struct net_proto_family rose_family_ops
= {
1515 .create
= rose_create
,
1516 .owner
= THIS_MODULE
,
1519 static const struct proto_ops rose_proto_ops
= {
1521 .owner
= THIS_MODULE
,
1522 .release
= rose_release
,
1524 .connect
= rose_connect
,
1525 .socketpair
= sock_no_socketpair
,
1526 .accept
= rose_accept
,
1527 .getname
= rose_getname
,
1528 .poll
= datagram_poll
,
1529 .ioctl
= rose_ioctl
,
1530 .listen
= rose_listen
,
1531 .shutdown
= sock_no_shutdown
,
1532 .setsockopt
= rose_setsockopt
,
1533 .getsockopt
= rose_getsockopt
,
1534 .sendmsg
= rose_sendmsg
,
1535 .recvmsg
= rose_recvmsg
,
1536 .mmap
= sock_no_mmap
,
1537 .sendpage
= sock_no_sendpage
,
1540 static struct notifier_block rose_dev_notifier
= {
1541 .notifier_call
= rose_device_event
,
1544 static struct net_device
**dev_rose
;
1546 static struct ax25_protocol rose_pid
= {
1548 .func
= rose_route_frame
1551 static struct ax25_linkfail rose_linkfail_notifier
= {
1552 .func
= rose_link_failed
1555 static int __init
rose_proto_init(void)
1560 if (rose_ndevs
> 0x7FFFFFFF/sizeof(struct net_device
*)) {
1561 printk(KERN_ERR
"ROSE: rose_proto_init - rose_ndevs parameter to large\n");
1566 rc
= proto_register(&rose_proto
, 0);
1570 rose_callsign
= null_ax25_address
;
1572 dev_rose
= kzalloc(rose_ndevs
* sizeof(struct net_device
*), GFP_KERNEL
);
1573 if (dev_rose
== NULL
) {
1574 printk(KERN_ERR
"ROSE: rose_proto_init - unable to allocate device structure\n");
1576 goto out_proto_unregister
;
1579 for (i
= 0; i
< rose_ndevs
; i
++) {
1580 struct net_device
*dev
;
1581 char name
[IFNAMSIZ
];
1583 sprintf(name
, "rose%d", i
);
1584 dev
= alloc_netdev(0, name
, rose_setup
);
1586 printk(KERN_ERR
"ROSE: rose_proto_init - unable to allocate memory\n");
1590 rc
= register_netdev(dev
);
1592 printk(KERN_ERR
"ROSE: netdevice registration failed\n");
1596 rose_set_lockdep_key(dev
);
1600 sock_register(&rose_family_ops
);
1601 register_netdevice_notifier(&rose_dev_notifier
);
1603 ax25_register_pid(&rose_pid
);
1604 ax25_linkfail_register(&rose_linkfail_notifier
);
1606 #ifdef CONFIG_SYSCTL
1607 rose_register_sysctl();
1609 rose_loopback_init();
1611 rose_add_loopback_neigh();
1613 proc_net_fops_create(&init_net
, "rose", S_IRUGO
, &rose_info_fops
);
1614 proc_net_fops_create(&init_net
, "rose_neigh", S_IRUGO
, &rose_neigh_fops
);
1615 proc_net_fops_create(&init_net
, "rose_nodes", S_IRUGO
, &rose_nodes_fops
);
1616 proc_net_fops_create(&init_net
, "rose_routes", S_IRUGO
, &rose_routes_fops
);
1621 unregister_netdev(dev_rose
[i
]);
1622 free_netdev(dev_rose
[i
]);
1625 out_proto_unregister
:
1626 proto_unregister(&rose_proto
);
1629 module_init(rose_proto_init
);
1631 module_param(rose_ndevs
, int, 0);
1632 MODULE_PARM_DESC(rose_ndevs
, "number of ROSE devices");
1634 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1635 MODULE_DESCRIPTION("The amateur radio ROSE network layer protocol");
1636 MODULE_LICENSE("GPL");
1637 MODULE_ALIAS_NETPROTO(PF_ROSE
);
1639 static void __exit
rose_exit(void)
1643 proc_net_remove(&init_net
, "rose");
1644 proc_net_remove(&init_net
, "rose_neigh");
1645 proc_net_remove(&init_net
, "rose_nodes");
1646 proc_net_remove(&init_net
, "rose_routes");
1647 rose_loopback_clear();
1651 ax25_protocol_release(AX25_P_ROSE
);
1652 ax25_linkfail_release(&rose_linkfail_notifier
);
1654 if (ax25cmp(&rose_callsign
, &null_ax25_address
) != 0)
1655 ax25_listen_release(&rose_callsign
, NULL
);
1657 #ifdef CONFIG_SYSCTL
1658 rose_unregister_sysctl();
1660 unregister_netdevice_notifier(&rose_dev_notifier
);
1662 sock_unregister(PF_ROSE
);
1664 for (i
= 0; i
< rose_ndevs
; i
++) {
1665 struct net_device
*dev
= dev_rose
[i
];
1668 unregister_netdev(dev
);
1674 proto_unregister(&rose_proto
);
1677 module_exit(rose_exit
);