1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 *
4 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
5 * Copyright (C) Terry Dawson VK2KTJ (terry@animats.net)
6 */
7 #include <linux/errno.h>
8 #include <linux/types.h>
9 #include <linux/socket.h>
10 #include <linux/in.h>
11 #include <linux/kernel.h>
12 #include <linux/timer.h>
13 #include <linux/string.h>
14 #include <linux/sockios.h>
15 #include <linux/net.h>
16 #include <linux/slab.h>
17 #include <net/ax25.h>
18 #include <linux/inet.h>
19 #include <linux/netdevice.h>
20 #include <net/arp.h>
21 #include <linux/if_arp.h>
22 #include <linux/skbuff.h>
23 #include <net/sock.h>
24 #include <net/tcp_states.h>
25 #include <linux/uaccess.h>
26 #include <linux/fcntl.h>
27 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
28 #include <linux/mm.h>
29 #include <linux/interrupt.h>
30 #include <linux/notifier.h>
31 #include <linux/init.h>
32 #include <net/rose.h>
33 #include <linux/seq_file.h>
34 #include <linux/export.h>
35
36 static unsigned int rose_neigh_no = 1;
37
38 static struct rose_node *rose_node_list;
39 static DEFINE_SPINLOCK(rose_node_list_lock);
40 static struct rose_neigh *rose_neigh_list;
41 static DEFINE_SPINLOCK(rose_neigh_list_lock);
42 static struct rose_route *rose_route_list;
43 static DEFINE_SPINLOCK(rose_route_list_lock);
44
45 struct rose_neigh *rose_loopback_neigh;
46
47 /*
48 * Add a new route to a node, and in the process add the node and the
49 * neighbour if it is new.
50 */
rose_add_node(struct rose_route_struct * rose_route,struct net_device * dev)51 static int __must_check rose_add_node(struct rose_route_struct *rose_route,
52 struct net_device *dev)
53 {
54 struct rose_node *rose_node, *rose_tmpn, *rose_tmpp;
55 struct rose_neigh *rose_neigh;
56 int i, res = 0;
57
58 spin_lock_bh(&rose_node_list_lock);
59 spin_lock_bh(&rose_neigh_list_lock);
60
61 rose_node = rose_node_list;
62 while (rose_node != NULL) {
63 if ((rose_node->mask == rose_route->mask) &&
64 (rosecmpm(&rose_route->address, &rose_node->address,
65 rose_route->mask) == 0))
66 break;
67 rose_node = rose_node->next;
68 }
69
70 if (rose_node != NULL && rose_node->loopback) {
71 res = -EINVAL;
72 goto out;
73 }
74
75 rose_neigh = rose_neigh_list;
76 while (rose_neigh != NULL) {
77 if (ax25cmp(&rose_route->neighbour,
78 &rose_neigh->callsign) == 0 &&
79 rose_neigh->dev == dev)
80 break;
81 rose_neigh = rose_neigh->next;
82 }
83
84 if (rose_neigh == NULL) {
85 rose_neigh = kmalloc(sizeof(*rose_neigh), GFP_ATOMIC);
86 if (rose_neigh == NULL) {
87 res = -ENOMEM;
88 goto out;
89 }
90
91 rose_neigh->callsign = rose_route->neighbour;
92 rose_neigh->digipeat = NULL;
93 rose_neigh->ax25 = NULL;
94 rose_neigh->dev = dev;
95 rose_neigh->count = 0;
96 rose_neigh->dce_mode = 0;
97 rose_neigh->loopback = 0;
98 rose_neigh->number = rose_neigh_no++;
99 rose_neigh->restarted = 0;
100 refcount_set(&rose_neigh->use, 1);
101
102 skb_queue_head_init(&rose_neigh->queue);
103
104 timer_setup(&rose_neigh->ftimer, NULL, 0);
105 timer_setup(&rose_neigh->t0timer, NULL, 0);
106
107 if (rose_route->ndigis != 0) {
108 rose_neigh->digipeat =
109 kmalloc(sizeof(ax25_digi), GFP_ATOMIC);
110 if (rose_neigh->digipeat == NULL) {
111 kfree(rose_neigh);
112 res = -ENOMEM;
113 goto out;
114 }
115
116 rose_neigh->digipeat->ndigi = rose_route->ndigis;
117 rose_neigh->digipeat->lastrepeat = -1;
118
119 for (i = 0; i < rose_route->ndigis; i++) {
120 rose_neigh->digipeat->calls[i] =
121 rose_route->digipeaters[i];
122 rose_neigh->digipeat->repeated[i] = 0;
123 }
124 }
125
126 rose_neigh->next = rose_neigh_list;
127 rose_neigh_list = rose_neigh;
128 }
129
130 /*
131 * This is a new node to be inserted into the list. Find where it needs
132 * to be inserted into the list, and insert it. We want to be sure
133 * to order the list in descending order of mask size to ensure that
134 * later when we are searching this list the first match will be the
135 * best match.
136 */
137 if (rose_node == NULL) {
138 rose_tmpn = rose_node_list;
139 rose_tmpp = NULL;
140
141 while (rose_tmpn != NULL) {
142 if (rose_tmpn->mask > rose_route->mask) {
143 rose_tmpp = rose_tmpn;
144 rose_tmpn = rose_tmpn->next;
145 } else {
146 break;
147 }
148 }
149
150 /* create new node */
151 rose_node = kmalloc(sizeof(*rose_node), GFP_ATOMIC);
152 if (rose_node == NULL) {
153 res = -ENOMEM;
154 goto out;
155 }
156
157 rose_node->address = rose_route->address;
158 rose_node->mask = rose_route->mask;
159 rose_node->count = 1;
160 rose_node->loopback = 0;
161 rose_node->neighbour[0] = rose_neigh;
162
163 if (rose_tmpn == NULL) {
164 if (rose_tmpp == NULL) { /* Empty list */
165 rose_node_list = rose_node;
166 rose_node->next = NULL;
167 } else {
168 rose_tmpp->next = rose_node;
169 rose_node->next = NULL;
170 }
171 } else {
172 if (rose_tmpp == NULL) { /* 1st node */
173 rose_node->next = rose_node_list;
174 rose_node_list = rose_node;
175 } else {
176 rose_tmpp->next = rose_node;
177 rose_node->next = rose_tmpn;
178 }
179 }
180 rose_neigh->count++;
181 rose_neigh_hold(rose_neigh);
182
183 goto out;
184 }
185
186 /* We have space, slot it in */
187 if (rose_node->count < 3) {
188 rose_node->neighbour[rose_node->count] = rose_neigh;
189 rose_node->count++;
190 rose_neigh->count++;
191 rose_neigh_hold(rose_neigh);
192 }
193
194 out:
195 spin_unlock_bh(&rose_neigh_list_lock);
196 spin_unlock_bh(&rose_node_list_lock);
197
198 return res;
199 }
200
201 /*
202 * Caller is holding rose_node_list_lock.
203 */
rose_remove_node(struct rose_node * rose_node)204 static void rose_remove_node(struct rose_node *rose_node)
205 {
206 struct rose_node *s;
207
208 if ((s = rose_node_list) == rose_node) {
209 rose_node_list = rose_node->next;
210 kfree(rose_node);
211 return;
212 }
213
214 while (s != NULL && s->next != NULL) {
215 if (s->next == rose_node) {
216 s->next = rose_node->next;
217 kfree(rose_node);
218 return;
219 }
220
221 s = s->next;
222 }
223 }
224
225 /*
226 * Caller is holding rose_neigh_list_lock.
227 */
rose_remove_neigh(struct rose_neigh * rose_neigh)228 static void rose_remove_neigh(struct rose_neigh *rose_neigh)
229 {
230 struct rose_neigh *s;
231
232 timer_delete_sync(&rose_neigh->ftimer);
233 timer_delete_sync(&rose_neigh->t0timer);
234
235 skb_queue_purge(&rose_neigh->queue);
236
237 if ((s = rose_neigh_list) == rose_neigh) {
238 rose_neigh_list = rose_neigh->next;
239 return;
240 }
241
242 while (s != NULL && s->next != NULL) {
243 if (s->next == rose_neigh) {
244 s->next = rose_neigh->next;
245 return;
246 }
247
248 s = s->next;
249 }
250 }
251
252 /*
253 * Caller is holding rose_route_list_lock.
254 */
rose_remove_route(struct rose_route * rose_route)255 static void rose_remove_route(struct rose_route *rose_route)
256 {
257 struct rose_route *s;
258
259 if (rose_route->neigh1 != NULL)
260 rose_neigh_put(rose_route->neigh1);
261
262 if (rose_route->neigh2 != NULL)
263 rose_neigh_put(rose_route->neigh2);
264
265 if ((s = rose_route_list) == rose_route) {
266 rose_route_list = rose_route->next;
267 kfree(rose_route);
268 return;
269 }
270
271 while (s != NULL && s->next != NULL) {
272 if (s->next == rose_route) {
273 s->next = rose_route->next;
274 kfree(rose_route);
275 return;
276 }
277
278 s = s->next;
279 }
280 }
281
282 /*
283 * "Delete" a node. Strictly speaking remove a route to a node. The node
284 * is only deleted if no routes are left to it.
285 */
rose_del_node(struct rose_route_struct * rose_route,struct net_device * dev)286 static int rose_del_node(struct rose_route_struct *rose_route,
287 struct net_device *dev)
288 {
289 struct rose_node *rose_node;
290 struct rose_neigh *rose_neigh;
291 int i, err = 0;
292
293 spin_lock_bh(&rose_node_list_lock);
294 spin_lock_bh(&rose_neigh_list_lock);
295
296 rose_node = rose_node_list;
297 while (rose_node != NULL) {
298 if ((rose_node->mask == rose_route->mask) &&
299 (rosecmpm(&rose_route->address, &rose_node->address,
300 rose_route->mask) == 0))
301 break;
302 rose_node = rose_node->next;
303 }
304
305 if (rose_node == NULL || rose_node->loopback) {
306 err = -EINVAL;
307 goto out;
308 }
309
310 rose_neigh = rose_neigh_list;
311 while (rose_neigh != NULL) {
312 if (ax25cmp(&rose_route->neighbour,
313 &rose_neigh->callsign) == 0 &&
314 rose_neigh->dev == dev)
315 break;
316 rose_neigh = rose_neigh->next;
317 }
318
319 if (rose_neigh == NULL) {
320 err = -EINVAL;
321 goto out;
322 }
323
324 for (i = 0; i < rose_node->count; i++) {
325 if (rose_node->neighbour[i] == rose_neigh) {
326 rose_neigh->count--;
327 rose_neigh_put(rose_neigh);
328
329 if (rose_neigh->count == 0) {
330 rose_remove_neigh(rose_neigh);
331 rose_neigh_put(rose_neigh);
332 }
333
334 rose_node->count--;
335
336 if (rose_node->count == 0) {
337 rose_remove_node(rose_node);
338 } else {
339 switch (i) {
340 case 0:
341 rose_node->neighbour[0] =
342 rose_node->neighbour[1];
343 fallthrough;
344 case 1:
345 rose_node->neighbour[1] =
346 rose_node->neighbour[2];
347 break;
348 case 2:
349 break;
350 }
351 }
352 goto out;
353 }
354 }
355 err = -EINVAL;
356
357 out:
358 spin_unlock_bh(&rose_neigh_list_lock);
359 spin_unlock_bh(&rose_node_list_lock);
360
361 return err;
362 }
363
364 /*
365 * Add the loopback neighbour.
366 */
rose_add_loopback_neigh(void)367 void rose_add_loopback_neigh(void)
368 {
369 struct rose_neigh *sn;
370
371 rose_loopback_neigh = kmalloc(sizeof(struct rose_neigh), GFP_KERNEL);
372 if (!rose_loopback_neigh)
373 return;
374 sn = rose_loopback_neigh;
375
376 sn->callsign = null_ax25_address;
377 sn->digipeat = NULL;
378 sn->ax25 = NULL;
379 sn->dev = NULL;
380 sn->count = 0;
381 sn->dce_mode = 1;
382 sn->loopback = 1;
383 sn->number = rose_neigh_no++;
384 sn->restarted = 1;
385 refcount_set(&sn->use, 1);
386
387 skb_queue_head_init(&sn->queue);
388
389 timer_setup(&sn->ftimer, NULL, 0);
390 timer_setup(&sn->t0timer, NULL, 0);
391
392 spin_lock_bh(&rose_neigh_list_lock);
393 sn->next = rose_neigh_list;
394 rose_neigh_list = sn;
395 spin_unlock_bh(&rose_neigh_list_lock);
396 }
397
398 /*
399 * Add a loopback node.
400 */
rose_add_loopback_node(const rose_address * address)401 int rose_add_loopback_node(const rose_address *address)
402 {
403 struct rose_node *rose_node;
404 int err = 0;
405
406 spin_lock_bh(&rose_node_list_lock);
407
408 rose_node = rose_node_list;
409 while (rose_node != NULL) {
410 if ((rose_node->mask == 10) &&
411 (rosecmpm(address, &rose_node->address, 10) == 0) &&
412 rose_node->loopback)
413 break;
414 rose_node = rose_node->next;
415 }
416
417 if (rose_node != NULL)
418 goto out;
419
420 if ((rose_node = kmalloc(sizeof(*rose_node), GFP_ATOMIC)) == NULL) {
421 err = -ENOMEM;
422 goto out;
423 }
424
425 rose_node->address = *address;
426 rose_node->mask = 10;
427 rose_node->count = 1;
428 rose_node->loopback = 1;
429 rose_node->neighbour[0] = rose_loopback_neigh;
430
431 /* Insert at the head of list. Address is always mask=10 */
432 rose_node->next = rose_node_list;
433 rose_node_list = rose_node;
434
435 rose_loopback_neigh->count++;
436 rose_neigh_hold(rose_loopback_neigh);
437
438 out:
439 spin_unlock_bh(&rose_node_list_lock);
440
441 return err;
442 }
443
444 /*
445 * Delete a loopback node.
446 */
rose_del_loopback_node(const rose_address * address)447 void rose_del_loopback_node(const rose_address *address)
448 {
449 struct rose_node *rose_node;
450
451 spin_lock_bh(&rose_node_list_lock);
452
453 rose_node = rose_node_list;
454 while (rose_node != NULL) {
455 if ((rose_node->mask == 10) &&
456 (rosecmpm(address, &rose_node->address, 10) == 0) &&
457 rose_node->loopback)
458 break;
459 rose_node = rose_node->next;
460 }
461
462 if (rose_node == NULL)
463 goto out;
464
465 rose_remove_node(rose_node);
466
467 rose_loopback_neigh->count--;
468 rose_neigh_put(rose_loopback_neigh);
469
470 out:
471 spin_unlock_bh(&rose_node_list_lock);
472 }
473
474 /*
475 * A device has been removed. Remove its routes and neighbours.
476 */
rose_rt_device_down(struct net_device * dev)477 void rose_rt_device_down(struct net_device *dev)
478 {
479 struct rose_neigh *s, *rose_neigh;
480 struct rose_node *t, *rose_node;
481 int i;
482
483 spin_lock_bh(&rose_node_list_lock);
484 spin_lock_bh(&rose_neigh_list_lock);
485 rose_neigh = rose_neigh_list;
486 while (rose_neigh != NULL) {
487 s = rose_neigh;
488 rose_neigh = rose_neigh->next;
489
490 if (s->dev != dev)
491 continue;
492
493 rose_node = rose_node_list;
494
495 while (rose_node != NULL) {
496 t = rose_node;
497 rose_node = rose_node->next;
498
499 for (i = t->count - 1; i >= 0; i--) {
500 if (t->neighbour[i] != s)
501 continue;
502
503 t->count--;
504
505 memmove(&t->neighbour[i], &t->neighbour[i + 1],
506 sizeof(t->neighbour[0]) *
507 (t->count - i));
508 rose_neigh_put(s);
509 }
510
511 if (t->count <= 0)
512 rose_remove_node(t);
513 }
514
515 rose_remove_neigh(s);
516 rose_neigh_put(s);
517 }
518 spin_unlock_bh(&rose_neigh_list_lock);
519 spin_unlock_bh(&rose_node_list_lock);
520 }
521
522 #if 0 /* Currently unused */
523 /*
524 * A device has been removed. Remove its links.
525 */
526 void rose_route_device_down(struct net_device *dev)
527 {
528 struct rose_route *s, *rose_route;
529
530 spin_lock_bh(&rose_route_list_lock);
531 rose_route = rose_route_list;
532 while (rose_route != NULL) {
533 s = rose_route;
534 rose_route = rose_route->next;
535
536 if (s->neigh1->dev == dev || s->neigh2->dev == dev)
537 rose_remove_route(s);
538 }
539 spin_unlock_bh(&rose_route_list_lock);
540 }
541 #endif
542
543 /*
544 * Clear all nodes and neighbours out, except for neighbours with
545 * active connections going through them.
546 * Do not clear loopback neighbour and nodes.
547 */
rose_clear_routes(void)548 static int rose_clear_routes(void)
549 {
550 struct rose_neigh *s, *rose_neigh;
551 struct rose_node *t, *rose_node;
552 int i;
553
554 spin_lock_bh(&rose_node_list_lock);
555 spin_lock_bh(&rose_neigh_list_lock);
556
557 rose_neigh = rose_neigh_list;
558 rose_node = rose_node_list;
559
560 while (rose_node != NULL) {
561 t = rose_node;
562 rose_node = rose_node->next;
563
564 if (!t->loopback) {
565 for (i = 0; i < t->count; i++)
566 rose_neigh_put(t->neighbour[i]);
567 rose_remove_node(t);
568 }
569 }
570
571 while (rose_neigh != NULL) {
572 s = rose_neigh;
573 rose_neigh = rose_neigh->next;
574
575 if (!s->loopback) {
576 rose_remove_neigh(s);
577 rose_neigh_put(s);
578 }
579 }
580
581 spin_unlock_bh(&rose_neigh_list_lock);
582 spin_unlock_bh(&rose_node_list_lock);
583
584 return 0;
585 }
586
587 /*
588 * Check that the device given is a valid AX.25 interface that is "up".
589 * called with RTNL
590 */
rose_ax25_dev_find(char * devname)591 static struct net_device *rose_ax25_dev_find(char *devname)
592 {
593 struct net_device *dev;
594
595 if ((dev = __dev_get_by_name(&init_net, devname)) == NULL)
596 return NULL;
597
598 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
599 return dev;
600
601 return NULL;
602 }
603
604 /*
605 * Find the first active ROSE device, usually "rose0".
606 */
rose_dev_first(void)607 struct net_device *rose_dev_first(void)
608 {
609 struct net_device *dev, *first = NULL;
610
611 rcu_read_lock();
612 for_each_netdev_rcu(&init_net, dev) {
613 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE)
614 if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
615 first = dev;
616 }
617 if (first)
618 dev_hold(first);
619 rcu_read_unlock();
620
621 return first;
622 }
623
624 /*
625 * Find the ROSE device for the given address.
626 */
rose_dev_get(rose_address * addr)627 struct net_device *rose_dev_get(rose_address *addr)
628 {
629 struct net_device *dev;
630
631 rcu_read_lock();
632 for_each_netdev_rcu(&init_net, dev) {
633 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE &&
634 rosecmp(addr, (const rose_address *)dev->dev_addr) == 0) {
635 dev_hold(dev);
636 goto out;
637 }
638 }
639 dev = NULL;
640 out:
641 rcu_read_unlock();
642 return dev;
643 }
644
rose_dev_exists(rose_address * addr)645 static int rose_dev_exists(rose_address *addr)
646 {
647 struct net_device *dev;
648
649 rcu_read_lock();
650 for_each_netdev_rcu(&init_net, dev) {
651 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE &&
652 rosecmp(addr, (const rose_address *)dev->dev_addr) == 0)
653 goto out;
654 }
655 dev = NULL;
656 out:
657 rcu_read_unlock();
658 return dev != NULL;
659 }
660
661
662
663
rose_route_free_lci(unsigned int lci,struct rose_neigh * neigh)664 struct rose_route *rose_route_free_lci(unsigned int lci, struct rose_neigh *neigh)
665 {
666 struct rose_route *rose_route;
667
668 for (rose_route = rose_route_list; rose_route != NULL; rose_route = rose_route->next)
669 if ((rose_route->neigh1 == neigh && rose_route->lci1 == lci) ||
670 (rose_route->neigh2 == neigh && rose_route->lci2 == lci))
671 return rose_route;
672
673 return NULL;
674 }
675
676 /*
677 * Find a neighbour or a route given a ROSE address.
678 */
rose_get_neigh(rose_address * addr,unsigned char * cause,unsigned char * diagnostic,int route_frame)679 struct rose_neigh *rose_get_neigh(rose_address *addr, unsigned char *cause,
680 unsigned char *diagnostic, int route_frame)
681 {
682 struct rose_neigh *res = NULL;
683 struct rose_node *node;
684 int failed = 0;
685 int i;
686
687 if (!route_frame) spin_lock_bh(&rose_node_list_lock);
688 for (node = rose_node_list; node != NULL; node = node->next) {
689 if (rosecmpm(addr, &node->address, node->mask) == 0) {
690 for (i = 0; i < node->count; i++) {
691 if (node->neighbour[i]->restarted) {
692 res = node->neighbour[i];
693 rose_neigh_hold(node->neighbour[i]);
694 goto out;
695 }
696 }
697 }
698 }
699 if (!route_frame) { /* connect request */
700 for (node = rose_node_list; node != NULL; node = node->next) {
701 if (rosecmpm(addr, &node->address, node->mask) == 0) {
702 for (i = 0; i < node->count; i++) {
703 if (!rose_ftimer_running(node->neighbour[i])) {
704 res = node->neighbour[i];
705 rose_neigh_hold(node->neighbour[i]);
706 goto out;
707 }
708 failed = 1;
709 }
710 }
711 }
712 }
713
714 if (failed) {
715 *cause = ROSE_OUT_OF_ORDER;
716 *diagnostic = 0;
717 } else {
718 *cause = ROSE_NOT_OBTAINABLE;
719 *diagnostic = 0;
720 }
721
722 out:
723 if (!route_frame) spin_unlock_bh(&rose_node_list_lock);
724 return res;
725 }
726
727 /*
728 * Handle the ioctls that control the routing functions.
729 */
rose_rt_ioctl(unsigned int cmd,void __user * arg)730 int rose_rt_ioctl(unsigned int cmd, void __user *arg)
731 {
732 struct rose_route_struct rose_route;
733 struct net_device *dev;
734 int err;
735
736 switch (cmd) {
737 case SIOCADDRT:
738 if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
739 return -EFAULT;
740 if ((dev = rose_ax25_dev_find(rose_route.device)) == NULL)
741 return -EINVAL;
742 if (rose_dev_exists(&rose_route.address)) /* Can't add routes to ourself */
743 return -EINVAL;
744 if (rose_route.mask > 10) /* Mask can't be more than 10 digits */
745 return -EINVAL;
746 if (rose_route.ndigis > AX25_MAX_DIGIS)
747 return -EINVAL;
748 err = rose_add_node(&rose_route, dev);
749 return err;
750
751 case SIOCDELRT:
752 if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
753 return -EFAULT;
754 if ((dev = rose_ax25_dev_find(rose_route.device)) == NULL)
755 return -EINVAL;
756 err = rose_del_node(&rose_route, dev);
757 return err;
758
759 case SIOCRSCLRRT:
760 return rose_clear_routes();
761
762 default:
763 return -EINVAL;
764 }
765
766 return 0;
767 }
768
rose_del_route_by_neigh(struct rose_neigh * rose_neigh)769 static void rose_del_route_by_neigh(struct rose_neigh *rose_neigh)
770 {
771 struct rose_route *rose_route, *s;
772
773 rose_neigh->restarted = 0;
774
775 rose_stop_t0timer(rose_neigh);
776 rose_start_ftimer(rose_neigh);
777
778 skb_queue_purge(&rose_neigh->queue);
779
780 spin_lock_bh(&rose_route_list_lock);
781
782 rose_route = rose_route_list;
783
784 while (rose_route != NULL) {
785 if ((rose_route->neigh1 == rose_neigh && rose_route->neigh2 == rose_neigh) ||
786 (rose_route->neigh1 == rose_neigh && rose_route->neigh2 == NULL) ||
787 (rose_route->neigh2 == rose_neigh && rose_route->neigh1 == NULL)) {
788 s = rose_route->next;
789 rose_remove_route(rose_route);
790 rose_route = s;
791 continue;
792 }
793
794 if (rose_route->neigh1 == rose_neigh) {
795 rose_neigh_put(rose_route->neigh1);
796 rose_route->neigh1 = NULL;
797 rose_transmit_clear_request(rose_route->neigh2, rose_route->lci2, ROSE_OUT_OF_ORDER, 0);
798 }
799
800 if (rose_route->neigh2 == rose_neigh) {
801 rose_neigh_put(rose_route->neigh2);
802 rose_route->neigh2 = NULL;
803 rose_transmit_clear_request(rose_route->neigh1, rose_route->lci1, ROSE_OUT_OF_ORDER, 0);
804 }
805
806 rose_route = rose_route->next;
807 }
808 spin_unlock_bh(&rose_route_list_lock);
809 }
810
811 /*
812 * A level 2 link has timed out, therefore it appears to be a poor link,
813 * then don't use that neighbour until it is reset. Blow away all through
814 * routes and connections using this route.
815 */
rose_link_failed(ax25_cb * ax25,int reason)816 void rose_link_failed(ax25_cb *ax25, int reason)
817 {
818 struct rose_neigh *rose_neigh;
819
820 spin_lock_bh(&rose_neigh_list_lock);
821 rose_neigh = rose_neigh_list;
822 while (rose_neigh != NULL) {
823 if (rose_neigh->ax25 == ax25)
824 break;
825 rose_neigh = rose_neigh->next;
826 }
827
828 if (rose_neigh != NULL) {
829 rose_neigh->ax25 = NULL;
830 ax25_cb_put(ax25);
831
832 rose_del_route_by_neigh(rose_neigh);
833 rose_kill_by_neigh(rose_neigh);
834 }
835 spin_unlock_bh(&rose_neigh_list_lock);
836 }
837
838 /*
839 * A device has been "downed" remove its link status. Blow away all
840 * through routes and connections that use this device.
841 */
rose_link_device_down(struct net_device * dev)842 void rose_link_device_down(struct net_device *dev)
843 {
844 struct rose_neigh *rose_neigh;
845
846 for (rose_neigh = rose_neigh_list; rose_neigh != NULL; rose_neigh = rose_neigh->next) {
847 if (rose_neigh->dev == dev) {
848 rose_del_route_by_neigh(rose_neigh);
849 rose_kill_by_neigh(rose_neigh);
850 }
851 }
852 }
853
854 /*
855 * Route a frame to an appropriate AX.25 connection.
856 * A NULL ax25_cb indicates an internally generated frame.
857 */
rose_route_frame(struct sk_buff * skb,ax25_cb * ax25)858 int rose_route_frame(struct sk_buff *skb, ax25_cb *ax25)
859 {
860 struct rose_neigh *rose_neigh, *new_neigh;
861 struct rose_route *rose_route;
862 struct rose_facilities_struct facilities;
863 rose_address *src_addr, *dest_addr;
864 struct sock *sk;
865 unsigned short frametype;
866 unsigned int lci, new_lci;
867 unsigned char cause, diagnostic;
868 struct net_device *dev;
869 int res = 0;
870 char buf[11];
871
872 if (skb->len < ROSE_MIN_LEN)
873 return res;
874
875 if (!ax25)
876 return rose_loopback_queue(skb, NULL);
877
878 frametype = skb->data[2];
879 lci = ((skb->data[0] << 8) & 0xF00) + ((skb->data[1] << 0) & 0x0FF);
880 if (frametype == ROSE_CALL_REQUEST &&
881 (skb->len <= ROSE_CALL_REQ_FACILITIES_OFF ||
882 skb->data[ROSE_CALL_REQ_ADDR_LEN_OFF] !=
883 ROSE_CALL_REQ_ADDR_LEN_VAL))
884 return res;
885 src_addr = (rose_address *)(skb->data + ROSE_CALL_REQ_SRC_ADDR_OFF);
886 dest_addr = (rose_address *)(skb->data + ROSE_CALL_REQ_DEST_ADDR_OFF);
887
888 spin_lock_bh(&rose_neigh_list_lock);
889 spin_lock_bh(&rose_route_list_lock);
890
891 rose_neigh = rose_neigh_list;
892 while (rose_neigh != NULL) {
893 if (ax25cmp(&ax25->dest_addr, &rose_neigh->callsign) == 0 &&
894 ax25->ax25_dev->dev == rose_neigh->dev)
895 break;
896 rose_neigh = rose_neigh->next;
897 }
898
899 if (rose_neigh == NULL) {
900 printk("rose_route : unknown neighbour or device %s\n",
901 ax2asc(buf, &ax25->dest_addr));
902 goto out;
903 }
904
905 /*
906 * Obviously the link is working, halt the ftimer.
907 */
908 rose_stop_ftimer(rose_neigh);
909
910 /*
911 * LCI of zero is always for us, and its always a restart
912 * frame.
913 */
914 if (lci == 0) {
915 rose_link_rx_restart(skb, rose_neigh, frametype);
916 goto out;
917 }
918
919 /*
920 * Find an existing socket.
921 */
922 if ((sk = rose_find_socket(lci, rose_neigh)) != NULL) {
923 if (frametype == ROSE_CALL_REQUEST) {
924 struct rose_sock *rose = rose_sk(sk);
925
926 /* Remove an existing unused socket */
927 rose_clear_queues(sk);
928 rose->cause = ROSE_NETWORK_CONGESTION;
929 rose->diagnostic = 0;
930 rose_neigh_put(rose->neighbour);
931 rose->neighbour = NULL;
932 rose->lci = 0;
933 rose->state = ROSE_STATE_0;
934 sk->sk_state = TCP_CLOSE;
935 sk->sk_err = 0;
936 sk->sk_shutdown |= SEND_SHUTDOWN;
937 if (!sock_flag(sk, SOCK_DEAD)) {
938 sk->sk_state_change(sk);
939 sock_set_flag(sk, SOCK_DEAD);
940 }
941 }
942 else {
943 skb_reset_transport_header(skb);
944 res = rose_process_rx_frame(sk, skb);
945 goto out;
946 }
947 }
948
949 /*
950 * Is is a Call Request and is it for us ?
951 */
952 if (frametype == ROSE_CALL_REQUEST)
953 if ((dev = rose_dev_get(dest_addr)) != NULL) {
954 res = rose_rx_call_request(skb, dev, rose_neigh, lci);
955 dev_put(dev);
956 goto out;
957 }
958
959 if (!sysctl_rose_routing_control) {
960 rose_transmit_clear_request(rose_neigh, lci, ROSE_NOT_OBTAINABLE, 0);
961 goto out;
962 }
963
964 /*
965 * Route it to the next in line if we have an entry for it.
966 */
967 rose_route = rose_route_list;
968 while (rose_route != NULL) {
969 if (rose_route->lci1 == lci &&
970 rose_route->neigh1 == rose_neigh) {
971 if (frametype == ROSE_CALL_REQUEST) {
972 /* F6FBB - Remove an existing unused route */
973 rose_remove_route(rose_route);
974 break;
975 } else if (rose_route->neigh2 != NULL) {
976 skb->data[0] &= 0xF0;
977 skb->data[0] |= (rose_route->lci2 >> 8) & 0x0F;
978 skb->data[1] = (rose_route->lci2 >> 0) & 0xFF;
979 rose_transmit_link(skb, rose_route->neigh2);
980 if (frametype == ROSE_CLEAR_CONFIRMATION)
981 rose_remove_route(rose_route);
982 res = 1;
983 goto out;
984 } else {
985 if (frametype == ROSE_CLEAR_CONFIRMATION)
986 rose_remove_route(rose_route);
987 goto out;
988 }
989 }
990 if (rose_route->lci2 == lci &&
991 rose_route->neigh2 == rose_neigh) {
992 if (frametype == ROSE_CALL_REQUEST) {
993 /* F6FBB - Remove an existing unused route */
994 rose_remove_route(rose_route);
995 break;
996 } else if (rose_route->neigh1 != NULL) {
997 skb->data[0] &= 0xF0;
998 skb->data[0] |= (rose_route->lci1 >> 8) & 0x0F;
999 skb->data[1] = (rose_route->lci1 >> 0) & 0xFF;
1000 rose_transmit_link(skb, rose_route->neigh1);
1001 if (frametype == ROSE_CLEAR_CONFIRMATION)
1002 rose_remove_route(rose_route);
1003 res = 1;
1004 goto out;
1005 } else {
1006 if (frametype == ROSE_CLEAR_CONFIRMATION)
1007 rose_remove_route(rose_route);
1008 goto out;
1009 }
1010 }
1011 rose_route = rose_route->next;
1012 }
1013
1014 /*
1015 * We know that:
1016 * 1. The frame isn't for us,
1017 * 2. It isn't "owned" by any existing route.
1018 */
1019 if (frametype != ROSE_CALL_REQUEST) { /* XXX */
1020 res = 0;
1021 goto out;
1022 }
1023
1024 memset(&facilities, 0x00, sizeof(struct rose_facilities_struct));
1025
1026 if (!rose_parse_facilities(skb->data + ROSE_CALL_REQ_FACILITIES_OFF,
1027 skb->len - ROSE_CALL_REQ_FACILITIES_OFF,
1028 &facilities)) {
1029 rose_transmit_clear_request(rose_neigh, lci, ROSE_INVALID_FACILITY, 76);
1030 goto out;
1031 }
1032
1033 /*
1034 * Check for routing loops.
1035 */
1036 rose_route = rose_route_list;
1037 while (rose_route != NULL) {
1038 if (rose_route->rand == facilities.rand &&
1039 rosecmp(src_addr, &rose_route->src_addr) == 0 &&
1040 ax25cmp(&facilities.dest_call, &rose_route->src_call) == 0 &&
1041 ax25cmp(&facilities.source_call, &rose_route->dest_call) == 0) {
1042 rose_transmit_clear_request(rose_neigh, lci, ROSE_NOT_OBTAINABLE, 120);
1043 goto out;
1044 }
1045 rose_route = rose_route->next;
1046 }
1047
1048 if ((new_neigh = rose_get_neigh(dest_addr, &cause, &diagnostic, 1)) == NULL) {
1049 rose_transmit_clear_request(rose_neigh, lci, cause, diagnostic);
1050 goto out;
1051 }
1052
1053 if ((new_lci = rose_new_lci(new_neigh)) == 0) {
1054 rose_transmit_clear_request(rose_neigh, lci, ROSE_NETWORK_CONGESTION, 71);
1055 goto put_neigh;
1056 }
1057
1058 if ((rose_route = kmalloc(sizeof(*rose_route), GFP_ATOMIC)) == NULL) {
1059 rose_transmit_clear_request(rose_neigh, lci, ROSE_NETWORK_CONGESTION, 120);
1060 goto put_neigh;
1061 }
1062
1063 rose_route->lci1 = lci;
1064 rose_route->src_addr = *src_addr;
1065 rose_route->dest_addr = *dest_addr;
1066 rose_route->src_call = facilities.dest_call;
1067 rose_route->dest_call = facilities.source_call;
1068 rose_route->rand = facilities.rand;
1069 rose_route->neigh1 = rose_neigh;
1070 rose_route->lci2 = new_lci;
1071 rose_route->neigh2 = new_neigh;
1072
1073 rose_neigh_hold(rose_route->neigh1);
1074 rose_neigh_hold(rose_route->neigh2);
1075
1076 rose_route->next = rose_route_list;
1077 rose_route_list = rose_route;
1078
1079 skb->data[0] &= 0xF0;
1080 skb->data[0] |= (rose_route->lci2 >> 8) & 0x0F;
1081 skb->data[1] = (rose_route->lci2 >> 0) & 0xFF;
1082
1083 rose_transmit_link(skb, rose_route->neigh2);
1084 res = 1;
1085
1086 put_neigh:
1087 rose_neigh_put(new_neigh);
1088 out:
1089 spin_unlock_bh(&rose_route_list_lock);
1090 spin_unlock_bh(&rose_neigh_list_lock);
1091
1092 return res;
1093 }
1094
1095 #ifdef CONFIG_PROC_FS
1096
rose_node_start(struct seq_file * seq,loff_t * pos)1097 static void *rose_node_start(struct seq_file *seq, loff_t *pos)
1098 __acquires(rose_node_list_lock)
1099 {
1100 struct rose_node *rose_node;
1101 int i = 1;
1102
1103 spin_lock_bh(&rose_node_list_lock);
1104 if (*pos == 0)
1105 return SEQ_START_TOKEN;
1106
1107 for (rose_node = rose_node_list; rose_node && i < *pos;
1108 rose_node = rose_node->next, ++i);
1109
1110 return (i == *pos) ? rose_node : NULL;
1111 }
1112
rose_node_next(struct seq_file * seq,void * v,loff_t * pos)1113 static void *rose_node_next(struct seq_file *seq, void *v, loff_t *pos)
1114 {
1115 ++*pos;
1116
1117 return (v == SEQ_START_TOKEN) ? rose_node_list
1118 : ((struct rose_node *)v)->next;
1119 }
1120
rose_node_stop(struct seq_file * seq,void * v)1121 static void rose_node_stop(struct seq_file *seq, void *v)
1122 __releases(rose_node_list_lock)
1123 {
1124 spin_unlock_bh(&rose_node_list_lock);
1125 }
1126
rose_node_show(struct seq_file * seq,void * v)1127 static int rose_node_show(struct seq_file *seq, void *v)
1128 {
1129 char rsbuf[11];
1130 int i;
1131
1132 if (v == SEQ_START_TOKEN)
1133 seq_puts(seq, "address mask n neigh neigh neigh\n");
1134 else {
1135 const struct rose_node *rose_node = v;
1136 seq_printf(seq, "%-10s %04d %d",
1137 rose2asc(rsbuf, &rose_node->address),
1138 rose_node->mask,
1139 rose_node->count);
1140
1141 for (i = 0; i < rose_node->count; i++)
1142 seq_printf(seq, " %05d", rose_node->neighbour[i]->number);
1143
1144 seq_puts(seq, "\n");
1145 }
1146 return 0;
1147 }
1148
1149 const struct seq_operations rose_node_seqops = {
1150 .start = rose_node_start,
1151 .next = rose_node_next,
1152 .stop = rose_node_stop,
1153 .show = rose_node_show,
1154 };
1155
rose_neigh_start(struct seq_file * seq,loff_t * pos)1156 static void *rose_neigh_start(struct seq_file *seq, loff_t *pos)
1157 __acquires(rose_neigh_list_lock)
1158 {
1159 struct rose_neigh *rose_neigh;
1160 int i = 1;
1161
1162 spin_lock_bh(&rose_neigh_list_lock);
1163 if (*pos == 0)
1164 return SEQ_START_TOKEN;
1165
1166 for (rose_neigh = rose_neigh_list; rose_neigh && i < *pos;
1167 rose_neigh = rose_neigh->next, ++i);
1168
1169 return (i == *pos) ? rose_neigh : NULL;
1170 }
1171
rose_neigh_next(struct seq_file * seq,void * v,loff_t * pos)1172 static void *rose_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
1173 {
1174 ++*pos;
1175
1176 return (v == SEQ_START_TOKEN) ? rose_neigh_list
1177 : ((struct rose_neigh *)v)->next;
1178 }
1179
rose_neigh_stop(struct seq_file * seq,void * v)1180 static void rose_neigh_stop(struct seq_file *seq, void *v)
1181 __releases(rose_neigh_list_lock)
1182 {
1183 spin_unlock_bh(&rose_neigh_list_lock);
1184 }
1185
rose_neigh_show(struct seq_file * seq,void * v)1186 static int rose_neigh_show(struct seq_file *seq, void *v)
1187 {
1188 char buf[11];
1189 int i;
1190
1191 if (v == SEQ_START_TOKEN)
1192 seq_puts(seq,
1193 "addr callsign dev count use mode restart t0 tf digipeaters\n");
1194 else {
1195 struct rose_neigh *rose_neigh = v;
1196
1197 /* if (!rose_neigh->loopback) { */
1198 seq_printf(seq, "%05d %-9s %-4s %3d %3d %3s %3s %3lu %3lu",
1199 rose_neigh->number,
1200 (rose_neigh->loopback) ? "RSLOOP-0" : ax2asc(buf, &rose_neigh->callsign),
1201 rose_neigh->dev ? rose_neigh->dev->name : "???",
1202 rose_neigh->count,
1203 refcount_read(&rose_neigh->use) - rose_neigh->count - 1,
1204 (rose_neigh->dce_mode) ? "DCE" : "DTE",
1205 (rose_neigh->restarted) ? "yes" : "no",
1206 ax25_display_timer(&rose_neigh->t0timer) / HZ,
1207 ax25_display_timer(&rose_neigh->ftimer) / HZ);
1208
1209 if (rose_neigh->digipeat != NULL) {
1210 for (i = 0; i < rose_neigh->digipeat->ndigi; i++)
1211 seq_printf(seq, " %s", ax2asc(buf, &rose_neigh->digipeat->calls[i]));
1212 }
1213
1214 seq_puts(seq, "\n");
1215 }
1216 return 0;
1217 }
1218
1219
1220 const struct seq_operations rose_neigh_seqops = {
1221 .start = rose_neigh_start,
1222 .next = rose_neigh_next,
1223 .stop = rose_neigh_stop,
1224 .show = rose_neigh_show,
1225 };
1226
rose_route_start(struct seq_file * seq,loff_t * pos)1227 static void *rose_route_start(struct seq_file *seq, loff_t *pos)
1228 __acquires(rose_route_list_lock)
1229 {
1230 struct rose_route *rose_route;
1231 int i = 1;
1232
1233 spin_lock_bh(&rose_route_list_lock);
1234 if (*pos == 0)
1235 return SEQ_START_TOKEN;
1236
1237 for (rose_route = rose_route_list; rose_route && i < *pos;
1238 rose_route = rose_route->next, ++i);
1239
1240 return (i == *pos) ? rose_route : NULL;
1241 }
1242
rose_route_next(struct seq_file * seq,void * v,loff_t * pos)1243 static void *rose_route_next(struct seq_file *seq, void *v, loff_t *pos)
1244 {
1245 ++*pos;
1246
1247 return (v == SEQ_START_TOKEN) ? rose_route_list
1248 : ((struct rose_route *)v)->next;
1249 }
1250
rose_route_stop(struct seq_file * seq,void * v)1251 static void rose_route_stop(struct seq_file *seq, void *v)
1252 __releases(rose_route_list_lock)
1253 {
1254 spin_unlock_bh(&rose_route_list_lock);
1255 }
1256
rose_route_show(struct seq_file * seq,void * v)1257 static int rose_route_show(struct seq_file *seq, void *v)
1258 {
1259 char buf[11], rsbuf[11];
1260
1261 if (v == SEQ_START_TOKEN)
1262 seq_puts(seq,
1263 "lci address callsign neigh <-> lci address callsign neigh\n");
1264 else {
1265 struct rose_route *rose_route = v;
1266
1267 if (rose_route->neigh1)
1268 seq_printf(seq,
1269 "%3.3X %-10s %-9s %05d ",
1270 rose_route->lci1,
1271 rose2asc(rsbuf, &rose_route->src_addr),
1272 ax2asc(buf, &rose_route->src_call),
1273 rose_route->neigh1->number);
1274 else
1275 seq_puts(seq,
1276 "000 * * 00000 ");
1277
1278 if (rose_route->neigh2)
1279 seq_printf(seq,
1280 "%3.3X %-10s %-9s %05d\n",
1281 rose_route->lci2,
1282 rose2asc(rsbuf, &rose_route->dest_addr),
1283 ax2asc(buf, &rose_route->dest_call),
1284 rose_route->neigh2->number);
1285 else
1286 seq_puts(seq,
1287 "000 * * 00000\n");
1288 }
1289 return 0;
1290 }
1291
1292 struct seq_operations rose_route_seqops = {
1293 .start = rose_route_start,
1294 .next = rose_route_next,
1295 .stop = rose_route_stop,
1296 .show = rose_route_show,
1297 };
1298 #endif /* CONFIG_PROC_FS */
1299
1300 /*
1301 * Release all memory associated with ROSE routing structures.
1302 */
rose_rt_free(void)1303 void __exit rose_rt_free(void)
1304 {
1305 struct rose_neigh *s, *rose_neigh = rose_neigh_list;
1306 struct rose_node *t, *rose_node = rose_node_list;
1307 struct rose_route *u, *rose_route = rose_route_list;
1308 int i;
1309
1310 while (rose_neigh != NULL) {
1311 s = rose_neigh;
1312 rose_neigh = rose_neigh->next;
1313
1314 rose_remove_neigh(s);
1315 rose_neigh_put(s);
1316 }
1317
1318 while (rose_node != NULL) {
1319 t = rose_node;
1320 rose_node = rose_node->next;
1321
1322 for (i = 0; i < t->count; i++)
1323 rose_neigh_put(t->neighbour[i]);
1324 rose_remove_node(t);
1325 }
1326
1327 while (rose_route != NULL) {
1328 u = rose_route;
1329 rose_route = rose_route->next;
1330
1331 rose_remove_route(u);
1332 }
1333 }
1334