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) Terry Dawson VK2KTJ (terry@animats.net)
10 #include <linux/errno.h>
11 #include <linux/types.h>
12 #include <linux/socket.h>
14 #include <linux/kernel.h>
15 #include <linux/timer.h>
16 #include <linux/string.h>
17 #include <linux/sockios.h>
18 #include <linux/net.h>
20 #include <linux/inet.h>
21 #include <linux/netdevice.h>
23 #include <linux/if_arp.h>
24 #include <linux/skbuff.h>
26 #include <net/tcp_states.h>
27 #include <asm/system.h>
28 #include <asm/uaccess.h>
29 #include <linux/fcntl.h>
30 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
32 #include <linux/interrupt.h>
33 #include <linux/notifier.h>
34 #include <linux/netfilter.h>
35 #include <linux/init.h>
37 #include <linux/seq_file.h>
39 static unsigned int rose_neigh_no
= 1;
41 static struct rose_node
*rose_node_list
;
42 static DEFINE_SPINLOCK(rose_node_list_lock
);
43 static struct rose_neigh
*rose_neigh_list
;
44 static DEFINE_SPINLOCK(rose_neigh_list_lock
);
45 static struct rose_route
*rose_route_list
;
46 static DEFINE_SPINLOCK(rose_route_list_lock
);
48 struct rose_neigh
*rose_loopback_neigh
;
51 * Add a new route to a node, and in the process add the node and the
52 * neighbour if it is new.
54 static int __must_check
rose_add_node(struct rose_route_struct
*rose_route
,
55 struct net_device
*dev
)
57 struct rose_node
*rose_node
, *rose_tmpn
, *rose_tmpp
;
58 struct rose_neigh
*rose_neigh
;
61 spin_lock_bh(&rose_node_list_lock
);
62 spin_lock_bh(&rose_neigh_list_lock
);
64 rose_node
= rose_node_list
;
65 while (rose_node
!= NULL
) {
66 if ((rose_node
->mask
== rose_route
->mask
) &&
67 (rosecmpm(&rose_route
->address
, &rose_node
->address
,
68 rose_route
->mask
) == 0))
70 rose_node
= rose_node
->next
;
73 if (rose_node
!= NULL
&& rose_node
->loopback
) {
78 rose_neigh
= rose_neigh_list
;
79 while (rose_neigh
!= NULL
) {
80 if (ax25cmp(&rose_route
->neighbour
,
81 &rose_neigh
->callsign
) == 0 &&
82 rose_neigh
->dev
== dev
)
84 rose_neigh
= rose_neigh
->next
;
87 if (rose_neigh
== NULL
) {
88 rose_neigh
= kmalloc(sizeof(*rose_neigh
), GFP_ATOMIC
);
89 if (rose_neigh
== NULL
) {
94 rose_neigh
->callsign
= rose_route
->neighbour
;
95 rose_neigh
->digipeat
= NULL
;
96 rose_neigh
->ax25
= NULL
;
97 rose_neigh
->dev
= dev
;
98 rose_neigh
->count
= 0;
100 rose_neigh
->dce_mode
= 0;
101 rose_neigh
->loopback
= 0;
102 rose_neigh
->number
= rose_neigh_no
++;
103 rose_neigh
->restarted
= 0;
105 skb_queue_head_init(&rose_neigh
->queue
);
107 init_timer(&rose_neigh
->ftimer
);
108 init_timer(&rose_neigh
->t0timer
);
110 if (rose_route
->ndigis
!= 0) {
111 if ((rose_neigh
->digipeat
= kmalloc(sizeof(ax25_digi
), GFP_KERNEL
)) == NULL
) {
117 rose_neigh
->digipeat
->ndigi
= rose_route
->ndigis
;
118 rose_neigh
->digipeat
->lastrepeat
= -1;
120 for (i
= 0; i
< rose_route
->ndigis
; i
++) {
121 rose_neigh
->digipeat
->calls
[i
] =
122 rose_route
->digipeaters
[i
];
123 rose_neigh
->digipeat
->repeated
[i
] = 0;
127 rose_neigh
->next
= rose_neigh_list
;
128 rose_neigh_list
= rose_neigh
;
132 * This is a new node to be inserted into the list. Find where it needs
133 * to be inserted into the list, and insert it. We want to be sure
134 * to order the list in descending order of mask size to ensure that
135 * later when we are searching this list the first match will be the
138 if (rose_node
== NULL
) {
139 rose_tmpn
= rose_node_list
;
142 while (rose_tmpn
!= NULL
) {
143 if (rose_tmpn
->mask
> rose_route
->mask
) {
144 rose_tmpp
= rose_tmpn
;
145 rose_tmpn
= rose_tmpn
->next
;
151 /* create new node */
152 rose_node
= kmalloc(sizeof(*rose_node
), GFP_ATOMIC
);
153 if (rose_node
== NULL
) {
158 rose_node
->address
= rose_route
->address
;
159 rose_node
->mask
= rose_route
->mask
;
160 rose_node
->count
= 1;
161 rose_node
->loopback
= 0;
162 rose_node
->neighbour
[0] = rose_neigh
;
164 if (rose_tmpn
== NULL
) {
165 if (rose_tmpp
== NULL
) { /* Empty list */
166 rose_node_list
= rose_node
;
167 rose_node
->next
= NULL
;
169 rose_tmpp
->next
= rose_node
;
170 rose_node
->next
= NULL
;
173 if (rose_tmpp
== NULL
) { /* 1st node */
174 rose_node
->next
= rose_node_list
;
175 rose_node_list
= rose_node
;
177 rose_tmpp
->next
= rose_node
;
178 rose_node
->next
= rose_tmpn
;
186 /* We have space, slot it in */
187 if (rose_node
->count
< 3) {
188 rose_node
->neighbour
[rose_node
->count
] = rose_neigh
;
194 spin_unlock_bh(&rose_neigh_list_lock
);
195 spin_unlock_bh(&rose_node_list_lock
);
201 * Caller is holding rose_node_list_lock.
203 static void rose_remove_node(struct rose_node
*rose_node
)
207 if ((s
= rose_node_list
) == rose_node
) {
208 rose_node_list
= rose_node
->next
;
213 while (s
!= NULL
&& s
->next
!= NULL
) {
214 if (s
->next
== rose_node
) {
215 s
->next
= rose_node
->next
;
225 * Caller is holding rose_neigh_list_lock.
227 static void rose_remove_neigh(struct rose_neigh
*rose_neigh
)
229 struct rose_neigh
*s
;
231 rose_stop_ftimer(rose_neigh
);
232 rose_stop_t0timer(rose_neigh
);
234 skb_queue_purge(&rose_neigh
->queue
);
236 if ((s
= rose_neigh_list
) == rose_neigh
) {
237 rose_neigh_list
= rose_neigh
->next
;
238 kfree(rose_neigh
->digipeat
);
243 while (s
!= NULL
&& s
->next
!= NULL
) {
244 if (s
->next
== rose_neigh
) {
245 s
->next
= rose_neigh
->next
;
246 kfree(rose_neigh
->digipeat
);
256 * Caller is holding rose_route_list_lock.
258 static void rose_remove_route(struct rose_route
*rose_route
)
260 struct rose_route
*s
;
262 if (rose_route
->neigh1
!= NULL
)
263 rose_route
->neigh1
->use
--;
265 if (rose_route
->neigh2
!= NULL
)
266 rose_route
->neigh2
->use
--;
268 if ((s
= rose_route_list
) == rose_route
) {
269 rose_route_list
= rose_route
->next
;
274 while (s
!= NULL
&& s
->next
!= NULL
) {
275 if (s
->next
== rose_route
) {
276 s
->next
= rose_route
->next
;
286 * "Delete" a node. Strictly speaking remove a route to a node. The node
287 * is only deleted if no routes are left to it.
289 static int rose_del_node(struct rose_route_struct
*rose_route
,
290 struct net_device
*dev
)
292 struct rose_node
*rose_node
;
293 struct rose_neigh
*rose_neigh
;
296 spin_lock_bh(&rose_node_list_lock
);
297 spin_lock_bh(&rose_neigh_list_lock
);
299 rose_node
= rose_node_list
;
300 while (rose_node
!= NULL
) {
301 if ((rose_node
->mask
== rose_route
->mask
) &&
302 (rosecmpm(&rose_route
->address
, &rose_node
->address
,
303 rose_route
->mask
) == 0))
305 rose_node
= rose_node
->next
;
308 if (rose_node
== NULL
|| rose_node
->loopback
) {
313 rose_neigh
= rose_neigh_list
;
314 while (rose_neigh
!= NULL
) {
315 if (ax25cmp(&rose_route
->neighbour
,
316 &rose_neigh
->callsign
) == 0 &&
317 rose_neigh
->dev
== dev
)
319 rose_neigh
= rose_neigh
->next
;
322 if (rose_neigh
== NULL
) {
327 for (i
= 0; i
< rose_node
->count
; i
++) {
328 if (rose_node
->neighbour
[i
] == rose_neigh
) {
331 if (rose_neigh
->count
== 0 && rose_neigh
->use
== 0)
332 rose_remove_neigh(rose_neigh
);
336 if (rose_node
->count
== 0) {
337 rose_remove_node(rose_node
);
341 rose_node
->neighbour
[0] =
342 rose_node
->neighbour
[1];
344 rose_node
->neighbour
[1] =
345 rose_node
->neighbour
[2];
356 spin_unlock_bh(&rose_neigh_list_lock
);
357 spin_unlock_bh(&rose_node_list_lock
);
363 * Add the loopback neighbour.
365 void rose_add_loopback_neigh(void)
367 struct rose_neigh
*sn
;
369 rose_loopback_neigh
= kmalloc(sizeof(struct rose_neigh
), GFP_KERNEL
);
370 if (!rose_loopback_neigh
)
372 sn
= rose_loopback_neigh
;
374 sn
->callsign
= null_ax25_address
;
382 sn
->number
= rose_neigh_no
++;
385 skb_queue_head_init(&sn
->queue
);
387 init_timer(&sn
->ftimer
);
388 init_timer(&sn
->t0timer
);
390 spin_lock_bh(&rose_neigh_list_lock
);
391 sn
->next
= rose_neigh_list
;
392 rose_neigh_list
= sn
;
393 spin_unlock_bh(&rose_neigh_list_lock
);
397 * Add a loopback node.
399 int rose_add_loopback_node(rose_address
*address
)
401 struct rose_node
*rose_node
;
404 spin_lock_bh(&rose_node_list_lock
);
406 rose_node
= rose_node_list
;
407 while (rose_node
!= NULL
) {
408 if ((rose_node
->mask
== 10) &&
409 (rosecmpm(address
, &rose_node
->address
, 10) == 0) &&
412 rose_node
= rose_node
->next
;
415 if (rose_node
!= NULL
)
418 if ((rose_node
= kmalloc(sizeof(*rose_node
), GFP_ATOMIC
)) == NULL
) {
423 rose_node
->address
= *address
;
424 rose_node
->mask
= 10;
425 rose_node
->count
= 1;
426 rose_node
->loopback
= 1;
427 rose_node
->neighbour
[0] = rose_loopback_neigh
;
429 /* Insert at the head of list. Address is always mask=10 */
430 rose_node
->next
= rose_node_list
;
431 rose_node_list
= rose_node
;
433 rose_loopback_neigh
->count
++;
436 spin_unlock_bh(&rose_node_list_lock
);
442 * Delete a loopback node.
444 void rose_del_loopback_node(rose_address
*address
)
446 struct rose_node
*rose_node
;
448 spin_lock_bh(&rose_node_list_lock
);
450 rose_node
= rose_node_list
;
451 while (rose_node
!= NULL
) {
452 if ((rose_node
->mask
== 10) &&
453 (rosecmpm(address
, &rose_node
->address
, 10) == 0) &&
456 rose_node
= rose_node
->next
;
459 if (rose_node
== NULL
)
462 rose_remove_node(rose_node
);
464 rose_loopback_neigh
->count
--;
467 spin_unlock_bh(&rose_node_list_lock
);
471 * A device has been removed. Remove its routes and neighbours.
473 void rose_rt_device_down(struct net_device
*dev
)
475 struct rose_neigh
*s
, *rose_neigh
;
476 struct rose_node
*t
, *rose_node
;
479 spin_lock_bh(&rose_node_list_lock
);
480 spin_lock_bh(&rose_neigh_list_lock
);
481 rose_neigh
= rose_neigh_list
;
482 while (rose_neigh
!= NULL
) {
484 rose_neigh
= rose_neigh
->next
;
489 rose_node
= rose_node_list
;
491 while (rose_node
!= NULL
) {
493 rose_node
= rose_node
->next
;
495 for (i
= 0; i
< t
->count
; i
++) {
496 if (t
->neighbour
[i
] != s
)
503 t
->neighbour
[0] = t
->neighbour
[1];
505 t
->neighbour
[1] = t
->neighbour
[2];
515 rose_remove_neigh(s
);
517 spin_unlock_bh(&rose_neigh_list_lock
);
518 spin_unlock_bh(&rose_node_list_lock
);
521 #if 0 /* Currently unused */
523 * A device has been removed. Remove its links.
525 void rose_route_device_down(struct net_device
*dev
)
527 struct rose_route
*s
, *rose_route
;
529 spin_lock_bh(&rose_route_list_lock
);
530 rose_route
= rose_route_list
;
531 while (rose_route
!= NULL
) {
533 rose_route
= rose_route
->next
;
535 if (s
->neigh1
->dev
== dev
|| s
->neigh2
->dev
== dev
)
536 rose_remove_route(s
);
538 spin_unlock_bh(&rose_route_list_lock
);
543 * Clear all nodes and neighbours out, except for neighbours with
544 * active connections going through them.
545 * Do not clear loopback neighbour and nodes.
547 static int rose_clear_routes(void)
549 struct rose_neigh
*s
, *rose_neigh
;
550 struct rose_node
*t
, *rose_node
;
552 spin_lock_bh(&rose_node_list_lock
);
553 spin_lock_bh(&rose_neigh_list_lock
);
555 rose_neigh
= rose_neigh_list
;
556 rose_node
= rose_node_list
;
558 while (rose_node
!= NULL
) {
560 rose_node
= rose_node
->next
;
565 while (rose_neigh
!= NULL
) {
567 rose_neigh
= rose_neigh
->next
;
569 if (s
->use
== 0 && !s
->loopback
) {
571 rose_remove_neigh(s
);
575 spin_unlock_bh(&rose_neigh_list_lock
);
576 spin_unlock_bh(&rose_node_list_lock
);
582 * Check that the device given is a valid AX.25 interface that is "up".
585 static struct net_device
*rose_ax25_dev_find(char *devname
)
587 struct net_device
*dev
;
589 if ((dev
= __dev_get_by_name(&init_net
, devname
)) == NULL
)
592 if ((dev
->flags
& IFF_UP
) && dev
->type
== ARPHRD_AX25
)
599 * Find the first active ROSE device, usually "rose0".
601 struct net_device
*rose_dev_first(void)
603 struct net_device
*dev
, *first
= NULL
;
606 for_each_netdev_rcu(&init_net
, dev
) {
607 if ((dev
->flags
& IFF_UP
) && dev
->type
== ARPHRD_ROSE
)
608 if (first
== NULL
|| strncmp(dev
->name
, first
->name
, 3) < 0)
617 * Find the ROSE device for the given address.
619 struct net_device
*rose_dev_get(rose_address
*addr
)
621 struct net_device
*dev
;
624 for_each_netdev_rcu(&init_net
, dev
) {
625 if ((dev
->flags
& IFF_UP
) && dev
->type
== ARPHRD_ROSE
&& rosecmp(addr
, (rose_address
*)dev
->dev_addr
) == 0) {
636 static int rose_dev_exists(rose_address
*addr
)
638 struct net_device
*dev
;
641 for_each_netdev_rcu(&init_net
, dev
) {
642 if ((dev
->flags
& IFF_UP
) && dev
->type
== ARPHRD_ROSE
&& rosecmp(addr
, (rose_address
*)dev
->dev_addr
) == 0)
654 struct rose_route
*rose_route_free_lci(unsigned int lci
, struct rose_neigh
*neigh
)
656 struct rose_route
*rose_route
;
658 for (rose_route
= rose_route_list
; rose_route
!= NULL
; rose_route
= rose_route
->next
)
659 if ((rose_route
->neigh1
== neigh
&& rose_route
->lci1
== lci
) ||
660 (rose_route
->neigh2
== neigh
&& rose_route
->lci2
== lci
))
667 * Find a neighbour or a route given a ROSE address.
669 struct rose_neigh
*rose_get_neigh(rose_address
*addr
, unsigned char *cause
,
670 unsigned char *diagnostic
, int new)
672 struct rose_neigh
*res
= NULL
;
673 struct rose_node
*node
;
677 if (!new) spin_lock_bh(&rose_node_list_lock
);
678 for (node
= rose_node_list
; node
!= NULL
; node
= node
->next
) {
679 if (rosecmpm(addr
, &node
->address
, node
->mask
) == 0) {
680 for (i
= 0; i
< node
->count
; i
++) {
682 if (node
->neighbour
[i
]->restarted
) {
683 res
= node
->neighbour
[i
];
688 if (!rose_ftimer_running(node
->neighbour
[i
])) {
689 res
= node
->neighbour
[i
];
699 *cause
= ROSE_OUT_OF_ORDER
;
702 *cause
= ROSE_NOT_OBTAINABLE
;
707 if (!new) spin_unlock_bh(&rose_node_list_lock
);
713 * Handle the ioctls that control the routing functions.
715 int rose_rt_ioctl(unsigned int cmd
, void __user
*arg
)
717 struct rose_route_struct rose_route
;
718 struct net_device
*dev
;
723 if (copy_from_user(&rose_route
, arg
, sizeof(struct rose_route_struct
)))
725 if ((dev
= rose_ax25_dev_find(rose_route
.device
)) == NULL
)
727 if (rose_dev_exists(&rose_route
.address
)) /* Can't add routes to ourself */
729 if (rose_route
.mask
> 10) /* Mask can't be more than 10 digits */
731 if (rose_route
.ndigis
> AX25_MAX_DIGIS
)
733 err
= rose_add_node(&rose_route
, dev
);
737 if (copy_from_user(&rose_route
, arg
, sizeof(struct rose_route_struct
)))
739 if ((dev
= rose_ax25_dev_find(rose_route
.device
)) == NULL
)
741 err
= rose_del_node(&rose_route
, dev
);
745 return rose_clear_routes();
754 static void rose_del_route_by_neigh(struct rose_neigh
*rose_neigh
)
756 struct rose_route
*rose_route
, *s
;
758 rose_neigh
->restarted
= 0;
760 rose_stop_t0timer(rose_neigh
);
761 rose_start_ftimer(rose_neigh
);
763 skb_queue_purge(&rose_neigh
->queue
);
765 spin_lock_bh(&rose_route_list_lock
);
767 rose_route
= rose_route_list
;
769 while (rose_route
!= NULL
) {
770 if ((rose_route
->neigh1
== rose_neigh
&& rose_route
->neigh2
== rose_neigh
) ||
771 (rose_route
->neigh1
== rose_neigh
&& rose_route
->neigh2
== NULL
) ||
772 (rose_route
->neigh2
== rose_neigh
&& rose_route
->neigh1
== NULL
)) {
773 s
= rose_route
->next
;
774 rose_remove_route(rose_route
);
779 if (rose_route
->neigh1
== rose_neigh
) {
780 rose_route
->neigh1
->use
--;
781 rose_route
->neigh1
= NULL
;
782 rose_transmit_clear_request(rose_route
->neigh2
, rose_route
->lci2
, ROSE_OUT_OF_ORDER
, 0);
785 if (rose_route
->neigh2
== rose_neigh
) {
786 rose_route
->neigh2
->use
--;
787 rose_route
->neigh2
= NULL
;
788 rose_transmit_clear_request(rose_route
->neigh1
, rose_route
->lci1
, ROSE_OUT_OF_ORDER
, 0);
791 rose_route
= rose_route
->next
;
793 spin_unlock_bh(&rose_route_list_lock
);
797 * A level 2 link has timed out, therefore it appears to be a poor link,
798 * then don't use that neighbour until it is reset. Blow away all through
799 * routes and connections using this route.
801 void rose_link_failed(ax25_cb
*ax25
, int reason
)
803 struct rose_neigh
*rose_neigh
;
805 spin_lock_bh(&rose_neigh_list_lock
);
806 rose_neigh
= rose_neigh_list
;
807 while (rose_neigh
!= NULL
) {
808 if (rose_neigh
->ax25
== ax25
)
810 rose_neigh
= rose_neigh
->next
;
813 if (rose_neigh
!= NULL
) {
814 rose_neigh
->ax25
= NULL
;
816 rose_del_route_by_neigh(rose_neigh
);
817 rose_kill_by_neigh(rose_neigh
);
819 spin_unlock_bh(&rose_neigh_list_lock
);
823 * A device has been "downed" remove its link status. Blow away all
824 * through routes and connections that use this device.
826 void rose_link_device_down(struct net_device
*dev
)
828 struct rose_neigh
*rose_neigh
;
830 for (rose_neigh
= rose_neigh_list
; rose_neigh
!= NULL
; rose_neigh
= rose_neigh
->next
) {
831 if (rose_neigh
->dev
== dev
) {
832 rose_del_route_by_neigh(rose_neigh
);
833 rose_kill_by_neigh(rose_neigh
);
839 * Route a frame to an appropriate AX.25 connection.
841 int rose_route_frame(struct sk_buff
*skb
, ax25_cb
*ax25
)
843 struct rose_neigh
*rose_neigh
, *new_neigh
;
844 struct rose_route
*rose_route
;
845 struct rose_facilities_struct facilities
;
846 rose_address
*src_addr
, *dest_addr
;
848 unsigned short frametype
;
849 unsigned int lci
, new_lci
;
850 unsigned char cause
, diagnostic
;
851 struct net_device
*dev
;
856 if (call_in_firewall(PF_ROSE
, skb
->dev
, skb
->data
, NULL
, &skb
) != FW_ACCEPT
)
860 frametype
= skb
->data
[2];
861 lci
= ((skb
->data
[0] << 8) & 0xF00) + ((skb
->data
[1] << 0) & 0x0FF);
862 src_addr
= (rose_address
*)(skb
->data
+ 9);
863 dest_addr
= (rose_address
*)(skb
->data
+ 4);
865 spin_lock_bh(&rose_neigh_list_lock
);
866 spin_lock_bh(&rose_route_list_lock
);
868 rose_neigh
= rose_neigh_list
;
869 while (rose_neigh
!= NULL
) {
870 if (ax25cmp(&ax25
->dest_addr
, &rose_neigh
->callsign
) == 0 &&
871 ax25
->ax25_dev
->dev
== rose_neigh
->dev
)
873 rose_neigh
= rose_neigh
->next
;
876 if (rose_neigh
== NULL
) {
877 printk("rose_route : unknown neighbour or device %s\n",
878 ax2asc(buf
, &ax25
->dest_addr
));
883 * Obviously the link is working, halt the ftimer.
885 rose_stop_ftimer(rose_neigh
);
888 * LCI of zero is always for us, and its always a restart
892 rose_link_rx_restart(skb
, rose_neigh
, frametype
);
897 * Find an existing socket.
899 if ((sk
= rose_find_socket(lci
, rose_neigh
)) != NULL
) {
900 if (frametype
== ROSE_CALL_REQUEST
) {
901 struct rose_sock
*rose
= rose_sk(sk
);
903 /* Remove an existing unused socket */
904 rose_clear_queues(sk
);
905 rose
->cause
= ROSE_NETWORK_CONGESTION
;
906 rose
->diagnostic
= 0;
907 rose
->neighbour
->use
--;
908 rose
->neighbour
= NULL
;
910 rose
->state
= ROSE_STATE_0
;
911 sk
->sk_state
= TCP_CLOSE
;
913 sk
->sk_shutdown
|= SEND_SHUTDOWN
;
914 if (!sock_flag(sk
, SOCK_DEAD
)) {
915 sk
->sk_state_change(sk
);
916 sock_set_flag(sk
, SOCK_DEAD
);
920 skb_reset_transport_header(skb
);
921 res
= rose_process_rx_frame(sk
, skb
);
927 * Is is a Call Request and is it for us ?
929 if (frametype
== ROSE_CALL_REQUEST
)
930 if ((dev
= rose_dev_get(dest_addr
)) != NULL
) {
931 res
= rose_rx_call_request(skb
, dev
, rose_neigh
, lci
);
936 if (!sysctl_rose_routing_control
) {
937 rose_transmit_clear_request(rose_neigh
, lci
, ROSE_NOT_OBTAINABLE
, 0);
942 * Route it to the next in line if we have an entry for it.
944 rose_route
= rose_route_list
;
945 while (rose_route
!= NULL
) {
946 if (rose_route
->lci1
== lci
&&
947 rose_route
->neigh1
== rose_neigh
) {
948 if (frametype
== ROSE_CALL_REQUEST
) {
949 /* F6FBB - Remove an existing unused route */
950 rose_remove_route(rose_route
);
952 } else if (rose_route
->neigh2
!= NULL
) {
953 skb
->data
[0] &= 0xF0;
954 skb
->data
[0] |= (rose_route
->lci2
>> 8) & 0x0F;
955 skb
->data
[1] = (rose_route
->lci2
>> 0) & 0xFF;
956 rose_transmit_link(skb
, rose_route
->neigh2
);
957 if (frametype
== ROSE_CLEAR_CONFIRMATION
)
958 rose_remove_route(rose_route
);
962 if (frametype
== ROSE_CLEAR_CONFIRMATION
)
963 rose_remove_route(rose_route
);
967 if (rose_route
->lci2
== lci
&&
968 rose_route
->neigh2
== rose_neigh
) {
969 if (frametype
== ROSE_CALL_REQUEST
) {
970 /* F6FBB - Remove an existing unused route */
971 rose_remove_route(rose_route
);
973 } else if (rose_route
->neigh1
!= NULL
) {
974 skb
->data
[0] &= 0xF0;
975 skb
->data
[0] |= (rose_route
->lci1
>> 8) & 0x0F;
976 skb
->data
[1] = (rose_route
->lci1
>> 0) & 0xFF;
977 rose_transmit_link(skb
, rose_route
->neigh1
);
978 if (frametype
== ROSE_CLEAR_CONFIRMATION
)
979 rose_remove_route(rose_route
);
983 if (frametype
== ROSE_CLEAR_CONFIRMATION
)
984 rose_remove_route(rose_route
);
988 rose_route
= rose_route
->next
;
993 * 1. The frame isn't for us,
994 * 2. It isn't "owned" by any existing route.
996 if (frametype
!= ROSE_CALL_REQUEST
) { /* XXX */
1001 len
= (((skb
->data
[3] >> 4) & 0x0F) + 1) >> 1;
1002 len
+= (((skb
->data
[3] >> 0) & 0x0F) + 1) >> 1;
1004 memset(&facilities
, 0x00, sizeof(struct rose_facilities_struct
));
1006 if (!rose_parse_facilities(skb
->data
+ len
+ 4, &facilities
)) {
1007 rose_transmit_clear_request(rose_neigh
, lci
, ROSE_INVALID_FACILITY
, 76);
1012 * Check for routing loops.
1014 rose_route
= rose_route_list
;
1015 while (rose_route
!= NULL
) {
1016 if (rose_route
->rand
== facilities
.rand
&&
1017 rosecmp(src_addr
, &rose_route
->src_addr
) == 0 &&
1018 ax25cmp(&facilities
.dest_call
, &rose_route
->src_call
) == 0 &&
1019 ax25cmp(&facilities
.source_call
, &rose_route
->dest_call
) == 0) {
1020 rose_transmit_clear_request(rose_neigh
, lci
, ROSE_NOT_OBTAINABLE
, 120);
1023 rose_route
= rose_route
->next
;
1026 if ((new_neigh
= rose_get_neigh(dest_addr
, &cause
, &diagnostic
, 1)) == NULL
) {
1027 rose_transmit_clear_request(rose_neigh
, lci
, cause
, diagnostic
);
1031 if ((new_lci
= rose_new_lci(new_neigh
)) == 0) {
1032 rose_transmit_clear_request(rose_neigh
, lci
, ROSE_NETWORK_CONGESTION
, 71);
1036 if ((rose_route
= kmalloc(sizeof(*rose_route
), GFP_ATOMIC
)) == NULL
) {
1037 rose_transmit_clear_request(rose_neigh
, lci
, ROSE_NETWORK_CONGESTION
, 120);
1041 rose_route
->lci1
= lci
;
1042 rose_route
->src_addr
= *src_addr
;
1043 rose_route
->dest_addr
= *dest_addr
;
1044 rose_route
->src_call
= facilities
.dest_call
;
1045 rose_route
->dest_call
= facilities
.source_call
;
1046 rose_route
->rand
= facilities
.rand
;
1047 rose_route
->neigh1
= rose_neigh
;
1048 rose_route
->lci2
= new_lci
;
1049 rose_route
->neigh2
= new_neigh
;
1051 rose_route
->neigh1
->use
++;
1052 rose_route
->neigh2
->use
++;
1054 rose_route
->next
= rose_route_list
;
1055 rose_route_list
= rose_route
;
1057 skb
->data
[0] &= 0xF0;
1058 skb
->data
[0] |= (rose_route
->lci2
>> 8) & 0x0F;
1059 skb
->data
[1] = (rose_route
->lci2
>> 0) & 0xFF;
1061 rose_transmit_link(skb
, rose_route
->neigh2
);
1065 spin_unlock_bh(&rose_route_list_lock
);
1066 spin_unlock_bh(&rose_neigh_list_lock
);
1071 #ifdef CONFIG_PROC_FS
1073 static void *rose_node_start(struct seq_file
*seq
, loff_t
*pos
)
1074 __acquires(rose_node_list_lock
)
1076 struct rose_node
*rose_node
;
1079 spin_lock_bh(&rose_node_list_lock
);
1081 return SEQ_START_TOKEN
;
1083 for (rose_node
= rose_node_list
; rose_node
&& i
< *pos
;
1084 rose_node
= rose_node
->next
, ++i
);
1086 return (i
== *pos
) ? rose_node
: NULL
;
1089 static void *rose_node_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1093 return (v
== SEQ_START_TOKEN
) ? rose_node_list
1094 : ((struct rose_node
*)v
)->next
;
1097 static void rose_node_stop(struct seq_file
*seq
, void *v
)
1098 __releases(rose_node_list_lock
)
1100 spin_unlock_bh(&rose_node_list_lock
);
1103 static int rose_node_show(struct seq_file
*seq
, void *v
)
1108 if (v
== SEQ_START_TOKEN
)
1109 seq_puts(seq
, "address mask n neigh neigh neigh\n");
1111 const struct rose_node
*rose_node
= v
;
1112 /* if (rose_node->loopback) {
1113 seq_printf(seq, "%-10s %04d 1 loopback\n",
1114 rose2asc(rsbuf, &rose_node->address),
1117 seq_printf(seq
, "%-10s %04d %d",
1118 rose2asc(rsbuf
, &rose_node
->address
),
1122 for (i
= 0; i
< rose_node
->count
; i
++)
1123 seq_printf(seq
, " %05d",
1124 rose_node
->neighbour
[i
]->number
);
1126 seq_puts(seq
, "\n");
1132 static const struct seq_operations rose_node_seqops
= {
1133 .start
= rose_node_start
,
1134 .next
= rose_node_next
,
1135 .stop
= rose_node_stop
,
1136 .show
= rose_node_show
,
1139 static int rose_nodes_open(struct inode
*inode
, struct file
*file
)
1141 return seq_open(file
, &rose_node_seqops
);
1144 const struct file_operations rose_nodes_fops
= {
1145 .owner
= THIS_MODULE
,
1146 .open
= rose_nodes_open
,
1148 .llseek
= seq_lseek
,
1149 .release
= seq_release
,
1152 static void *rose_neigh_start(struct seq_file
*seq
, loff_t
*pos
)
1153 __acquires(rose_neigh_list_lock
)
1155 struct rose_neigh
*rose_neigh
;
1158 spin_lock_bh(&rose_neigh_list_lock
);
1160 return SEQ_START_TOKEN
;
1162 for (rose_neigh
= rose_neigh_list
; rose_neigh
&& i
< *pos
;
1163 rose_neigh
= rose_neigh
->next
, ++i
);
1165 return (i
== *pos
) ? rose_neigh
: NULL
;
1168 static void *rose_neigh_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1172 return (v
== SEQ_START_TOKEN
) ? rose_neigh_list
1173 : ((struct rose_neigh
*)v
)->next
;
1176 static void rose_neigh_stop(struct seq_file
*seq
, void *v
)
1177 __releases(rose_neigh_list_lock
)
1179 spin_unlock_bh(&rose_neigh_list_lock
);
1182 static int rose_neigh_show(struct seq_file
*seq
, void *v
)
1187 if (v
== SEQ_START_TOKEN
)
1189 "addr callsign dev count use mode restart t0 tf digipeaters\n");
1191 struct rose_neigh
*rose_neigh
= v
;
1193 /* if (!rose_neigh->loopback) { */
1194 seq_printf(seq
, "%05d %-9s %-4s %3d %3d %3s %3s %3lu %3lu",
1196 (rose_neigh
->loopback
) ? "RSLOOP-0" : ax2asc(buf
, &rose_neigh
->callsign
),
1197 rose_neigh
->dev
? rose_neigh
->dev
->name
: "???",
1200 (rose_neigh
->dce_mode
) ? "DCE" : "DTE",
1201 (rose_neigh
->restarted
) ? "yes" : "no",
1202 ax25_display_timer(&rose_neigh
->t0timer
) / HZ
,
1203 ax25_display_timer(&rose_neigh
->ftimer
) / HZ
);
1205 if (rose_neigh
->digipeat
!= NULL
) {
1206 for (i
= 0; i
< rose_neigh
->digipeat
->ndigi
; i
++)
1207 seq_printf(seq
, " %s", ax2asc(buf
, &rose_neigh
->digipeat
->calls
[i
]));
1210 seq_puts(seq
, "\n");
1216 static const struct seq_operations rose_neigh_seqops
= {
1217 .start
= rose_neigh_start
,
1218 .next
= rose_neigh_next
,
1219 .stop
= rose_neigh_stop
,
1220 .show
= rose_neigh_show
,
1223 static int rose_neigh_open(struct inode
*inode
, struct file
*file
)
1225 return seq_open(file
, &rose_neigh_seqops
);
1228 const struct file_operations rose_neigh_fops
= {
1229 .owner
= THIS_MODULE
,
1230 .open
= rose_neigh_open
,
1232 .llseek
= seq_lseek
,
1233 .release
= seq_release
,
1237 static void *rose_route_start(struct seq_file
*seq
, loff_t
*pos
)
1238 __acquires(rose_route_list_lock
)
1240 struct rose_route
*rose_route
;
1243 spin_lock_bh(&rose_route_list_lock
);
1245 return SEQ_START_TOKEN
;
1247 for (rose_route
= rose_route_list
; rose_route
&& i
< *pos
;
1248 rose_route
= rose_route
->next
, ++i
);
1250 return (i
== *pos
) ? rose_route
: NULL
;
1253 static void *rose_route_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1257 return (v
== SEQ_START_TOKEN
) ? rose_route_list
1258 : ((struct rose_route
*)v
)->next
;
1261 static void rose_route_stop(struct seq_file
*seq
, void *v
)
1262 __releases(rose_route_list_lock
)
1264 spin_unlock_bh(&rose_route_list_lock
);
1267 static int rose_route_show(struct seq_file
*seq
, void *v
)
1269 char buf
[11], rsbuf
[11];
1271 if (v
== SEQ_START_TOKEN
)
1273 "lci address callsign neigh <-> lci address callsign neigh\n");
1275 struct rose_route
*rose_route
= v
;
1277 if (rose_route
->neigh1
)
1279 "%3.3X %-10s %-9s %05d ",
1281 rose2asc(rsbuf
, &rose_route
->src_addr
),
1282 ax2asc(buf
, &rose_route
->src_call
),
1283 rose_route
->neigh1
->number
);
1288 if (rose_route
->neigh2
)
1290 "%3.3X %-10s %-9s %05d\n",
1292 rose2asc(rsbuf
, &rose_route
->dest_addr
),
1293 ax2asc(buf
, &rose_route
->dest_call
),
1294 rose_route
->neigh2
->number
);
1302 static const struct seq_operations rose_route_seqops
= {
1303 .start
= rose_route_start
,
1304 .next
= rose_route_next
,
1305 .stop
= rose_route_stop
,
1306 .show
= rose_route_show
,
1309 static int rose_route_open(struct inode
*inode
, struct file
*file
)
1311 return seq_open(file
, &rose_route_seqops
);
1314 const struct file_operations rose_routes_fops
= {
1315 .owner
= THIS_MODULE
,
1316 .open
= rose_route_open
,
1318 .llseek
= seq_lseek
,
1319 .release
= seq_release
,
1322 #endif /* CONFIG_PROC_FS */
1325 * Release all memory associated with ROSE routing structures.
1327 void __exit
rose_rt_free(void)
1329 struct rose_neigh
*s
, *rose_neigh
= rose_neigh_list
;
1330 struct rose_node
*t
, *rose_node
= rose_node_list
;
1331 struct rose_route
*u
, *rose_route
= rose_route_list
;
1333 while (rose_neigh
!= NULL
) {
1335 rose_neigh
= rose_neigh
->next
;
1337 rose_remove_neigh(s
);
1340 while (rose_node
!= NULL
) {
1342 rose_node
= rose_node
->next
;
1344 rose_remove_node(t
);
1347 while (rose_route
!= NULL
) {
1349 rose_route
= rose_route
->next
;
1351 rose_remove_route(u
);