Loading...
1/*
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.
6 *
7 * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
8 * Copyright Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
9 * Copyright Tomi Manninen OH2BNS (oh2bns@sral.fi)
10 */
11#include <linux/errno.h>
12#include <linux/types.h>
13#include <linux/socket.h>
14#include <linux/in.h>
15#include <linux/kernel.h>
16#include <linux/timer.h>
17#include <linux/string.h>
18#include <linux/sockios.h>
19#include <linux/net.h>
20#include <linux/slab.h>
21#include <net/ax25.h>
22#include <linux/inet.h>
23#include <linux/netdevice.h>
24#include <net/arp.h>
25#include <linux/if_arp.h>
26#include <linux/skbuff.h>
27#include <net/sock.h>
28#include <linux/uaccess.h>
29#include <linux/fcntl.h>
30#include <linux/termios.h> /* For TIOCINQ/OUTQ */
31#include <linux/mm.h>
32#include <linux/interrupt.h>
33#include <linux/notifier.h>
34#include <linux/init.h>
35#include <linux/spinlock.h>
36#include <net/netrom.h>
37#include <linux/seq_file.h>
38#include <linux/export.h>
39
40static unsigned int nr_neigh_no = 1;
41
42static HLIST_HEAD(nr_node_list);
43static DEFINE_SPINLOCK(nr_node_list_lock);
44static HLIST_HEAD(nr_neigh_list);
45static DEFINE_SPINLOCK(nr_neigh_list_lock);
46
47static struct nr_node *nr_node_get(ax25_address *callsign)
48{
49 struct nr_node *found = NULL;
50 struct nr_node *nr_node;
51
52 spin_lock_bh(&nr_node_list_lock);
53 nr_node_for_each(nr_node, &nr_node_list)
54 if (ax25cmp(callsign, &nr_node->callsign) == 0) {
55 nr_node_hold(nr_node);
56 found = nr_node;
57 break;
58 }
59 spin_unlock_bh(&nr_node_list_lock);
60 return found;
61}
62
63static struct nr_neigh *nr_neigh_get_dev(ax25_address *callsign,
64 struct net_device *dev)
65{
66 struct nr_neigh *found = NULL;
67 struct nr_neigh *nr_neigh;
68
69 spin_lock_bh(&nr_neigh_list_lock);
70 nr_neigh_for_each(nr_neigh, &nr_neigh_list)
71 if (ax25cmp(callsign, &nr_neigh->callsign) == 0 &&
72 nr_neigh->dev == dev) {
73 nr_neigh_hold(nr_neigh);
74 found = nr_neigh;
75 break;
76 }
77 spin_unlock_bh(&nr_neigh_list_lock);
78 return found;
79}
80
81static void nr_remove_neigh(struct nr_neigh *);
82
83/*
84 * Add a new route to a node, and in the process add the node and the
85 * neighbour if it is new.
86 */
87static int __must_check nr_add_node(ax25_address *nr, const char *mnemonic,
88 ax25_address *ax25, ax25_digi *ax25_digi, struct net_device *dev,
89 int quality, int obs_count)
90{
91 struct nr_node *nr_node;
92 struct nr_neigh *nr_neigh;
93 struct nr_route nr_route;
94 int i, found;
95 struct net_device *odev;
96
97 if ((odev=nr_dev_get(nr)) != NULL) { /* Can't add routes to ourself */
98 dev_put(odev);
99 return -EINVAL;
100 }
101
102 nr_node = nr_node_get(nr);
103
104 nr_neigh = nr_neigh_get_dev(ax25, dev);
105
106 /*
107 * The L2 link to a neighbour has failed in the past
108 * and now a frame comes from this neighbour. We assume
109 * it was a temporary trouble with the link and reset the
110 * routes now (and not wait for a node broadcast).
111 */
112 if (nr_neigh != NULL && nr_neigh->failed != 0 && quality == 0) {
113 struct nr_node *nr_nodet;
114
115 spin_lock_bh(&nr_node_list_lock);
116 nr_node_for_each(nr_nodet, &nr_node_list) {
117 nr_node_lock(nr_nodet);
118 for (i = 0; i < nr_nodet->count; i++)
119 if (nr_nodet->routes[i].neighbour == nr_neigh)
120 if (i < nr_nodet->which)
121 nr_nodet->which = i;
122 nr_node_unlock(nr_nodet);
123 }
124 spin_unlock_bh(&nr_node_list_lock);
125 }
126
127 if (nr_neigh != NULL)
128 nr_neigh->failed = 0;
129
130 if (quality == 0 && nr_neigh != NULL && nr_node != NULL) {
131 nr_neigh_put(nr_neigh);
132 nr_node_put(nr_node);
133 return 0;
134 }
135
136 if (nr_neigh == NULL) {
137 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL) {
138 if (nr_node)
139 nr_node_put(nr_node);
140 return -ENOMEM;
141 }
142
143 nr_neigh->callsign = *ax25;
144 nr_neigh->digipeat = NULL;
145 nr_neigh->ax25 = NULL;
146 nr_neigh->dev = dev;
147 nr_neigh->quality = sysctl_netrom_default_path_quality;
148 nr_neigh->locked = 0;
149 nr_neigh->count = 0;
150 nr_neigh->number = nr_neigh_no++;
151 nr_neigh->failed = 0;
152 atomic_set(&nr_neigh->refcount, 1);
153
154 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
155 nr_neigh->digipeat = kmemdup(ax25_digi,
156 sizeof(*ax25_digi),
157 GFP_KERNEL);
158 if (nr_neigh->digipeat == NULL) {
159 kfree(nr_neigh);
160 if (nr_node)
161 nr_node_put(nr_node);
162 return -ENOMEM;
163 }
164 }
165
166 spin_lock_bh(&nr_neigh_list_lock);
167 hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
168 nr_neigh_hold(nr_neigh);
169 spin_unlock_bh(&nr_neigh_list_lock);
170 }
171
172 if (quality != 0 && ax25cmp(nr, ax25) == 0 && !nr_neigh->locked)
173 nr_neigh->quality = quality;
174
175 if (nr_node == NULL) {
176 if ((nr_node = kmalloc(sizeof(*nr_node), GFP_ATOMIC)) == NULL) {
177 if (nr_neigh)
178 nr_neigh_put(nr_neigh);
179 return -ENOMEM;
180 }
181
182 nr_node->callsign = *nr;
183 strcpy(nr_node->mnemonic, mnemonic);
184
185 nr_node->which = 0;
186 nr_node->count = 1;
187 atomic_set(&nr_node->refcount, 1);
188 spin_lock_init(&nr_node->node_lock);
189
190 nr_node->routes[0].quality = quality;
191 nr_node->routes[0].obs_count = obs_count;
192 nr_node->routes[0].neighbour = nr_neigh;
193
194 nr_neigh_hold(nr_neigh);
195 nr_neigh->count++;
196
197 spin_lock_bh(&nr_node_list_lock);
198 hlist_add_head(&nr_node->node_node, &nr_node_list);
199 /* refcount initialized at 1 */
200 spin_unlock_bh(&nr_node_list_lock);
201
202 return 0;
203 }
204 nr_node_lock(nr_node);
205
206 if (quality != 0)
207 strcpy(nr_node->mnemonic, mnemonic);
208
209 for (found = 0, i = 0; i < nr_node->count; i++) {
210 if (nr_node->routes[i].neighbour == nr_neigh) {
211 nr_node->routes[i].quality = quality;
212 nr_node->routes[i].obs_count = obs_count;
213 found = 1;
214 break;
215 }
216 }
217
218 if (!found) {
219 /* We have space at the bottom, slot it in */
220 if (nr_node->count < 3) {
221 nr_node->routes[2] = nr_node->routes[1];
222 nr_node->routes[1] = nr_node->routes[0];
223
224 nr_node->routes[0].quality = quality;
225 nr_node->routes[0].obs_count = obs_count;
226 nr_node->routes[0].neighbour = nr_neigh;
227
228 nr_node->which++;
229 nr_node->count++;
230 nr_neigh_hold(nr_neigh);
231 nr_neigh->count++;
232 } else {
233 /* It must be better than the worst */
234 if (quality > nr_node->routes[2].quality) {
235 nr_node->routes[2].neighbour->count--;
236 nr_neigh_put(nr_node->routes[2].neighbour);
237
238 if (nr_node->routes[2].neighbour->count == 0 && !nr_node->routes[2].neighbour->locked)
239 nr_remove_neigh(nr_node->routes[2].neighbour);
240
241 nr_node->routes[2].quality = quality;
242 nr_node->routes[2].obs_count = obs_count;
243 nr_node->routes[2].neighbour = nr_neigh;
244
245 nr_neigh_hold(nr_neigh);
246 nr_neigh->count++;
247 }
248 }
249 }
250
251 /* Now re-sort the routes in quality order */
252 switch (nr_node->count) {
253 case 3:
254 if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
255 switch (nr_node->which) {
256 case 0:
257 nr_node->which = 1;
258 break;
259 case 1:
260 nr_node->which = 0;
261 break;
262 }
263 nr_route = nr_node->routes[0];
264 nr_node->routes[0] = nr_node->routes[1];
265 nr_node->routes[1] = nr_route;
266 }
267 if (nr_node->routes[2].quality > nr_node->routes[1].quality) {
268 switch (nr_node->which) {
269 case 1: nr_node->which = 2;
270 break;
271
272 case 2: nr_node->which = 1;
273 break;
274
275 default:
276 break;
277 }
278 nr_route = nr_node->routes[1];
279 nr_node->routes[1] = nr_node->routes[2];
280 nr_node->routes[2] = nr_route;
281 }
282 case 2:
283 if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
284 switch (nr_node->which) {
285 case 0: nr_node->which = 1;
286 break;
287
288 case 1: nr_node->which = 0;
289 break;
290
291 default: break;
292 }
293 nr_route = nr_node->routes[0];
294 nr_node->routes[0] = nr_node->routes[1];
295 nr_node->routes[1] = nr_route;
296 }
297 case 1:
298 break;
299 }
300
301 for (i = 0; i < nr_node->count; i++) {
302 if (nr_node->routes[i].neighbour == nr_neigh) {
303 if (i < nr_node->which)
304 nr_node->which = i;
305 break;
306 }
307 }
308
309 nr_neigh_put(nr_neigh);
310 nr_node_unlock(nr_node);
311 nr_node_put(nr_node);
312 return 0;
313}
314
315static inline void __nr_remove_node(struct nr_node *nr_node)
316{
317 hlist_del_init(&nr_node->node_node);
318 nr_node_put(nr_node);
319}
320
321#define nr_remove_node_locked(__node) \
322 __nr_remove_node(__node)
323
324static void nr_remove_node(struct nr_node *nr_node)
325{
326 spin_lock_bh(&nr_node_list_lock);
327 __nr_remove_node(nr_node);
328 spin_unlock_bh(&nr_node_list_lock);
329}
330
331static inline void __nr_remove_neigh(struct nr_neigh *nr_neigh)
332{
333 hlist_del_init(&nr_neigh->neigh_node);
334 nr_neigh_put(nr_neigh);
335}
336
337#define nr_remove_neigh_locked(__neigh) \
338 __nr_remove_neigh(__neigh)
339
340static void nr_remove_neigh(struct nr_neigh *nr_neigh)
341{
342 spin_lock_bh(&nr_neigh_list_lock);
343 __nr_remove_neigh(nr_neigh);
344 spin_unlock_bh(&nr_neigh_list_lock);
345}
346
347/*
348 * "Delete" a node. Strictly speaking remove a route to a node. The node
349 * is only deleted if no routes are left to it.
350 */
351static int nr_del_node(ax25_address *callsign, ax25_address *neighbour, struct net_device *dev)
352{
353 struct nr_node *nr_node;
354 struct nr_neigh *nr_neigh;
355 int i;
356
357 nr_node = nr_node_get(callsign);
358
359 if (nr_node == NULL)
360 return -EINVAL;
361
362 nr_neigh = nr_neigh_get_dev(neighbour, dev);
363
364 if (nr_neigh == NULL) {
365 nr_node_put(nr_node);
366 return -EINVAL;
367 }
368
369 nr_node_lock(nr_node);
370 for (i = 0; i < nr_node->count; i++) {
371 if (nr_node->routes[i].neighbour == nr_neigh) {
372 nr_neigh->count--;
373 nr_neigh_put(nr_neigh);
374
375 if (nr_neigh->count == 0 && !nr_neigh->locked)
376 nr_remove_neigh(nr_neigh);
377 nr_neigh_put(nr_neigh);
378
379 nr_node->count--;
380
381 if (nr_node->count == 0) {
382 nr_remove_node(nr_node);
383 } else {
384 switch (i) {
385 case 0:
386 nr_node->routes[0] = nr_node->routes[1];
387 case 1:
388 nr_node->routes[1] = nr_node->routes[2];
389 case 2:
390 break;
391 }
392 nr_node_put(nr_node);
393 }
394 nr_node_unlock(nr_node);
395
396 return 0;
397 }
398 }
399 nr_neigh_put(nr_neigh);
400 nr_node_unlock(nr_node);
401 nr_node_put(nr_node);
402
403 return -EINVAL;
404}
405
406/*
407 * Lock a neighbour with a quality.
408 */
409static int __must_check nr_add_neigh(ax25_address *callsign,
410 ax25_digi *ax25_digi, struct net_device *dev, unsigned int quality)
411{
412 struct nr_neigh *nr_neigh;
413
414 nr_neigh = nr_neigh_get_dev(callsign, dev);
415 if (nr_neigh) {
416 nr_neigh->quality = quality;
417 nr_neigh->locked = 1;
418 nr_neigh_put(nr_neigh);
419 return 0;
420 }
421
422 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
423 return -ENOMEM;
424
425 nr_neigh->callsign = *callsign;
426 nr_neigh->digipeat = NULL;
427 nr_neigh->ax25 = NULL;
428 nr_neigh->dev = dev;
429 nr_neigh->quality = quality;
430 nr_neigh->locked = 1;
431 nr_neigh->count = 0;
432 nr_neigh->number = nr_neigh_no++;
433 nr_neigh->failed = 0;
434 atomic_set(&nr_neigh->refcount, 1);
435
436 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
437 nr_neigh->digipeat = kmemdup(ax25_digi, sizeof(*ax25_digi),
438 GFP_KERNEL);
439 if (nr_neigh->digipeat == NULL) {
440 kfree(nr_neigh);
441 return -ENOMEM;
442 }
443 }
444
445 spin_lock_bh(&nr_neigh_list_lock);
446 hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
447 /* refcount is initialized at 1 */
448 spin_unlock_bh(&nr_neigh_list_lock);
449
450 return 0;
451}
452
453/*
454 * "Delete" a neighbour. The neighbour is only removed if the number
455 * of nodes that may use it is zero.
456 */
457static int nr_del_neigh(ax25_address *callsign, struct net_device *dev, unsigned int quality)
458{
459 struct nr_neigh *nr_neigh;
460
461 nr_neigh = nr_neigh_get_dev(callsign, dev);
462
463 if (nr_neigh == NULL) return -EINVAL;
464
465 nr_neigh->quality = quality;
466 nr_neigh->locked = 0;
467
468 if (nr_neigh->count == 0)
469 nr_remove_neigh(nr_neigh);
470 nr_neigh_put(nr_neigh);
471
472 return 0;
473}
474
475/*
476 * Decrement the obsolescence count by one. If a route is reduced to a
477 * count of zero, remove it. Also remove any unlocked neighbours with
478 * zero nodes routing via it.
479 */
480static int nr_dec_obs(void)
481{
482 struct nr_neigh *nr_neigh;
483 struct nr_node *s;
484 struct hlist_node *nodet;
485 int i;
486
487 spin_lock_bh(&nr_node_list_lock);
488 nr_node_for_each_safe(s, nodet, &nr_node_list) {
489 nr_node_lock(s);
490 for (i = 0; i < s->count; i++) {
491 switch (s->routes[i].obs_count) {
492 case 0: /* A locked entry */
493 break;
494
495 case 1: /* From 1 -> 0 */
496 nr_neigh = s->routes[i].neighbour;
497
498 nr_neigh->count--;
499 nr_neigh_put(nr_neigh);
500
501 if (nr_neigh->count == 0 && !nr_neigh->locked)
502 nr_remove_neigh(nr_neigh);
503
504 s->count--;
505
506 switch (i) {
507 case 0:
508 s->routes[0] = s->routes[1];
509 /* Fallthrough */
510 case 1:
511 s->routes[1] = s->routes[2];
512 case 2:
513 break;
514 }
515 break;
516
517 default:
518 s->routes[i].obs_count--;
519 break;
520
521 }
522 }
523
524 if (s->count <= 0)
525 nr_remove_node_locked(s);
526 nr_node_unlock(s);
527 }
528 spin_unlock_bh(&nr_node_list_lock);
529
530 return 0;
531}
532
533/*
534 * A device has been removed. Remove its routes and neighbours.
535 */
536void nr_rt_device_down(struct net_device *dev)
537{
538 struct nr_neigh *s;
539 struct hlist_node *nodet, *node2t;
540 struct nr_node *t;
541 int i;
542
543 spin_lock_bh(&nr_neigh_list_lock);
544 nr_neigh_for_each_safe(s, nodet, &nr_neigh_list) {
545 if (s->dev == dev) {
546 spin_lock_bh(&nr_node_list_lock);
547 nr_node_for_each_safe(t, node2t, &nr_node_list) {
548 nr_node_lock(t);
549 for (i = 0; i < t->count; i++) {
550 if (t->routes[i].neighbour == s) {
551 t->count--;
552
553 switch (i) {
554 case 0:
555 t->routes[0] = t->routes[1];
556 case 1:
557 t->routes[1] = t->routes[2];
558 case 2:
559 break;
560 }
561 }
562 }
563
564 if (t->count <= 0)
565 nr_remove_node_locked(t);
566 nr_node_unlock(t);
567 }
568 spin_unlock_bh(&nr_node_list_lock);
569
570 nr_remove_neigh_locked(s);
571 }
572 }
573 spin_unlock_bh(&nr_neigh_list_lock);
574}
575
576/*
577 * Check that the device given is a valid AX.25 interface that is "up".
578 * Or a valid ethernet interface with an AX.25 callsign binding.
579 */
580static struct net_device *nr_ax25_dev_get(char *devname)
581{
582 struct net_device *dev;
583
584 if ((dev = dev_get_by_name(&init_net, devname)) == NULL)
585 return NULL;
586
587 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
588 return dev;
589
590 dev_put(dev);
591 return NULL;
592}
593
594/*
595 * Find the first active NET/ROM device, usually "nr0".
596 */
597struct net_device *nr_dev_first(void)
598{
599 struct net_device *dev, *first = NULL;
600
601 rcu_read_lock();
602 for_each_netdev_rcu(&init_net, dev) {
603 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM)
604 if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
605 first = dev;
606 }
607 if (first)
608 dev_hold(first);
609 rcu_read_unlock();
610
611 return first;
612}
613
614/*
615 * Find the NET/ROM device for the given callsign.
616 */
617struct net_device *nr_dev_get(ax25_address *addr)
618{
619 struct net_device *dev;
620
621 rcu_read_lock();
622 for_each_netdev_rcu(&init_net, dev) {
623 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM &&
624 ax25cmp(addr, (ax25_address *)dev->dev_addr) == 0) {
625 dev_hold(dev);
626 goto out;
627 }
628 }
629 dev = NULL;
630out:
631 rcu_read_unlock();
632 return dev;
633}
634
635static ax25_digi *nr_call_to_digi(ax25_digi *digi, int ndigis,
636 ax25_address *digipeaters)
637{
638 int i;
639
640 if (ndigis == 0)
641 return NULL;
642
643 for (i = 0; i < ndigis; i++) {
644 digi->calls[i] = digipeaters[i];
645 digi->repeated[i] = 0;
646 }
647
648 digi->ndigi = ndigis;
649 digi->lastrepeat = -1;
650
651 return digi;
652}
653
654/*
655 * Handle the ioctls that control the routing functions.
656 */
657int nr_rt_ioctl(unsigned int cmd, void __user *arg)
658{
659 struct nr_route_struct nr_route;
660 struct net_device *dev;
661 ax25_digi digi;
662 int ret;
663
664 switch (cmd) {
665 case SIOCADDRT:
666 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
667 return -EFAULT;
668 if (nr_route.ndigis > AX25_MAX_DIGIS)
669 return -EINVAL;
670 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
671 return -EINVAL;
672 switch (nr_route.type) {
673 case NETROM_NODE:
674 if (strnlen(nr_route.mnemonic, 7) == 7) {
675 ret = -EINVAL;
676 break;
677 }
678
679 ret = nr_add_node(&nr_route.callsign,
680 nr_route.mnemonic,
681 &nr_route.neighbour,
682 nr_call_to_digi(&digi, nr_route.ndigis,
683 nr_route.digipeaters),
684 dev, nr_route.quality,
685 nr_route.obs_count);
686 break;
687 case NETROM_NEIGH:
688 ret = nr_add_neigh(&nr_route.callsign,
689 nr_call_to_digi(&digi, nr_route.ndigis,
690 nr_route.digipeaters),
691 dev, nr_route.quality);
692 break;
693 default:
694 ret = -EINVAL;
695 }
696 dev_put(dev);
697 return ret;
698
699 case SIOCDELRT:
700 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
701 return -EFAULT;
702 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
703 return -EINVAL;
704 switch (nr_route.type) {
705 case NETROM_NODE:
706 ret = nr_del_node(&nr_route.callsign,
707 &nr_route.neighbour, dev);
708 break;
709 case NETROM_NEIGH:
710 ret = nr_del_neigh(&nr_route.callsign,
711 dev, nr_route.quality);
712 break;
713 default:
714 ret = -EINVAL;
715 }
716 dev_put(dev);
717 return ret;
718
719 case SIOCNRDECOBS:
720 return nr_dec_obs();
721
722 default:
723 return -EINVAL;
724 }
725
726 return 0;
727}
728
729/*
730 * A level 2 link has timed out, therefore it appears to be a poor link,
731 * then don't use that neighbour until it is reset.
732 */
733void nr_link_failed(ax25_cb *ax25, int reason)
734{
735 struct nr_neigh *s, *nr_neigh = NULL;
736 struct nr_node *nr_node = NULL;
737
738 spin_lock_bh(&nr_neigh_list_lock);
739 nr_neigh_for_each(s, &nr_neigh_list) {
740 if (s->ax25 == ax25) {
741 nr_neigh_hold(s);
742 nr_neigh = s;
743 break;
744 }
745 }
746 spin_unlock_bh(&nr_neigh_list_lock);
747
748 if (nr_neigh == NULL)
749 return;
750
751 nr_neigh->ax25 = NULL;
752 ax25_cb_put(ax25);
753
754 if (++nr_neigh->failed < sysctl_netrom_link_fails_count) {
755 nr_neigh_put(nr_neigh);
756 return;
757 }
758 spin_lock_bh(&nr_node_list_lock);
759 nr_node_for_each(nr_node, &nr_node_list) {
760 nr_node_lock(nr_node);
761 if (nr_node->which < nr_node->count &&
762 nr_node->routes[nr_node->which].neighbour == nr_neigh)
763 nr_node->which++;
764 nr_node_unlock(nr_node);
765 }
766 spin_unlock_bh(&nr_node_list_lock);
767 nr_neigh_put(nr_neigh);
768}
769
770/*
771 * Route a frame to an appropriate AX.25 connection. A NULL ax25_cb
772 * indicates an internally generated frame.
773 */
774int nr_route_frame(struct sk_buff *skb, ax25_cb *ax25)
775{
776 ax25_address *nr_src, *nr_dest;
777 struct nr_neigh *nr_neigh;
778 struct nr_node *nr_node;
779 struct net_device *dev;
780 unsigned char *dptr;
781 ax25_cb *ax25s;
782 int ret;
783 struct sk_buff *skbn;
784
785
786 nr_src = (ax25_address *)(skb->data + 0);
787 nr_dest = (ax25_address *)(skb->data + 7);
788
789 if (ax25 != NULL) {
790 ret = nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
791 ax25->ax25_dev->dev, 0,
792 sysctl_netrom_obsolescence_count_initialiser);
793 if (ret)
794 return ret;
795 }
796
797 if ((dev = nr_dev_get(nr_dest)) != NULL) { /* Its for me */
798 if (ax25 == NULL) /* Its from me */
799 ret = nr_loopback_queue(skb);
800 else
801 ret = nr_rx_frame(skb, dev);
802 dev_put(dev);
803 return ret;
804 }
805
806 if (!sysctl_netrom_routing_control && ax25 != NULL)
807 return 0;
808
809 /* Its Time-To-Live has expired */
810 if (skb->data[14] == 1) {
811 return 0;
812 }
813
814 nr_node = nr_node_get(nr_dest);
815 if (nr_node == NULL)
816 return 0;
817 nr_node_lock(nr_node);
818
819 if (nr_node->which >= nr_node->count) {
820 nr_node_unlock(nr_node);
821 nr_node_put(nr_node);
822 return 0;
823 }
824
825 nr_neigh = nr_node->routes[nr_node->which].neighbour;
826
827 if ((dev = nr_dev_first()) == NULL) {
828 nr_node_unlock(nr_node);
829 nr_node_put(nr_node);
830 return 0;
831 }
832
833 /* We are going to change the netrom headers so we should get our
834 own skb, we also did not know until now how much header space
835 we had to reserve... - RXQ */
836 if ((skbn=skb_copy_expand(skb, dev->hard_header_len, 0, GFP_ATOMIC)) == NULL) {
837 nr_node_unlock(nr_node);
838 nr_node_put(nr_node);
839 dev_put(dev);
840 return 0;
841 }
842 kfree_skb(skb);
843 skb=skbn;
844 skb->data[14]--;
845
846 dptr = skb_push(skb, 1);
847 *dptr = AX25_P_NETROM;
848
849 ax25s = nr_neigh->ax25;
850 nr_neigh->ax25 = ax25_send_frame(skb, 256,
851 (ax25_address *)dev->dev_addr,
852 &nr_neigh->callsign,
853 nr_neigh->digipeat, nr_neigh->dev);
854 if (ax25s)
855 ax25_cb_put(ax25s);
856
857 dev_put(dev);
858 ret = (nr_neigh->ax25 != NULL);
859 nr_node_unlock(nr_node);
860 nr_node_put(nr_node);
861
862 return ret;
863}
864
865#ifdef CONFIG_PROC_FS
866
867static void *nr_node_start(struct seq_file *seq, loff_t *pos)
868{
869 spin_lock_bh(&nr_node_list_lock);
870 return seq_hlist_start_head(&nr_node_list, *pos);
871}
872
873static void *nr_node_next(struct seq_file *seq, void *v, loff_t *pos)
874{
875 return seq_hlist_next(v, &nr_node_list, pos);
876}
877
878static void nr_node_stop(struct seq_file *seq, void *v)
879{
880 spin_unlock_bh(&nr_node_list_lock);
881}
882
883static int nr_node_show(struct seq_file *seq, void *v)
884{
885 char buf[11];
886 int i;
887
888 if (v == SEQ_START_TOKEN)
889 seq_puts(seq,
890 "callsign mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
891 else {
892 struct nr_node *nr_node = hlist_entry(v, struct nr_node,
893 node_node);
894
895 nr_node_lock(nr_node);
896 seq_printf(seq, "%-9s %-7s %d %d",
897 ax2asc(buf, &nr_node->callsign),
898 (nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
899 nr_node->which + 1,
900 nr_node->count);
901
902 for (i = 0; i < nr_node->count; i++) {
903 seq_printf(seq, " %3d %d %05d",
904 nr_node->routes[i].quality,
905 nr_node->routes[i].obs_count,
906 nr_node->routes[i].neighbour->number);
907 }
908 nr_node_unlock(nr_node);
909
910 seq_puts(seq, "\n");
911 }
912 return 0;
913}
914
915static const struct seq_operations nr_node_seqops = {
916 .start = nr_node_start,
917 .next = nr_node_next,
918 .stop = nr_node_stop,
919 .show = nr_node_show,
920};
921
922static int nr_node_info_open(struct inode *inode, struct file *file)
923{
924 return seq_open(file, &nr_node_seqops);
925}
926
927const struct file_operations nr_nodes_fops = {
928 .owner = THIS_MODULE,
929 .open = nr_node_info_open,
930 .read = seq_read,
931 .llseek = seq_lseek,
932 .release = seq_release,
933};
934
935static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
936{
937 spin_lock_bh(&nr_neigh_list_lock);
938 return seq_hlist_start_head(&nr_neigh_list, *pos);
939}
940
941static void *nr_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
942{
943 return seq_hlist_next(v, &nr_neigh_list, pos);
944}
945
946static void nr_neigh_stop(struct seq_file *seq, void *v)
947{
948 spin_unlock_bh(&nr_neigh_list_lock);
949}
950
951static int nr_neigh_show(struct seq_file *seq, void *v)
952{
953 char buf[11];
954 int i;
955
956 if (v == SEQ_START_TOKEN)
957 seq_puts(seq, "addr callsign dev qual lock count failed digipeaters\n");
958 else {
959 struct nr_neigh *nr_neigh;
960
961 nr_neigh = hlist_entry(v, struct nr_neigh, neigh_node);
962 seq_printf(seq, "%05d %-9s %-4s %3d %d %3d %3d",
963 nr_neigh->number,
964 ax2asc(buf, &nr_neigh->callsign),
965 nr_neigh->dev ? nr_neigh->dev->name : "???",
966 nr_neigh->quality,
967 nr_neigh->locked,
968 nr_neigh->count,
969 nr_neigh->failed);
970
971 if (nr_neigh->digipeat != NULL) {
972 for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
973 seq_printf(seq, " %s",
974 ax2asc(buf, &nr_neigh->digipeat->calls[i]));
975 }
976
977 seq_puts(seq, "\n");
978 }
979 return 0;
980}
981
982static const struct seq_operations nr_neigh_seqops = {
983 .start = nr_neigh_start,
984 .next = nr_neigh_next,
985 .stop = nr_neigh_stop,
986 .show = nr_neigh_show,
987};
988
989static int nr_neigh_info_open(struct inode *inode, struct file *file)
990{
991 return seq_open(file, &nr_neigh_seqops);
992}
993
994const struct file_operations nr_neigh_fops = {
995 .owner = THIS_MODULE,
996 .open = nr_neigh_info_open,
997 .read = seq_read,
998 .llseek = seq_lseek,
999 .release = seq_release,
1000};
1001
1002#endif
1003
1004/*
1005 * Free all memory associated with the nodes and routes lists.
1006 */
1007void __exit nr_rt_free(void)
1008{
1009 struct nr_neigh *s = NULL;
1010 struct nr_node *t = NULL;
1011 struct hlist_node *nodet;
1012
1013 spin_lock_bh(&nr_neigh_list_lock);
1014 spin_lock_bh(&nr_node_list_lock);
1015 nr_node_for_each_safe(t, nodet, &nr_node_list) {
1016 nr_node_lock(t);
1017 nr_remove_node_locked(t);
1018 nr_node_unlock(t);
1019 }
1020 nr_neigh_for_each_safe(s, nodet, &nr_neigh_list) {
1021 while(s->count) {
1022 s->count--;
1023 nr_neigh_put(s);
1024 }
1025 nr_remove_neigh_locked(s);
1026 }
1027 spin_unlock_bh(&nr_node_list_lock);
1028 spin_unlock_bh(&nr_neigh_list_lock);
1029}
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 *
4 * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
5 * Copyright Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
6 * Copyright Tomi Manninen OH2BNS (oh2bns@sral.fi)
7 */
8#include <linux/errno.h>
9#include <linux/types.h>
10#include <linux/socket.h>
11#include <linux/in.h>
12#include <linux/kernel.h>
13#include <linux/timer.h>
14#include <linux/string.h>
15#include <linux/sockios.h>
16#include <linux/net.h>
17#include <linux/slab.h>
18#include <net/ax25.h>
19#include <linux/inet.h>
20#include <linux/netdevice.h>
21#include <net/arp.h>
22#include <linux/if_arp.h>
23#include <linux/skbuff.h>
24#include <net/sock.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 <linux/spinlock.h>
33#include <net/netrom.h>
34#include <linux/seq_file.h>
35#include <linux/export.h>
36
37static unsigned int nr_neigh_no = 1;
38
39static HLIST_HEAD(nr_node_list);
40static DEFINE_SPINLOCK(nr_node_list_lock);
41static HLIST_HEAD(nr_neigh_list);
42static DEFINE_SPINLOCK(nr_neigh_list_lock);
43
44static struct nr_node *nr_node_get(ax25_address *callsign)
45{
46 struct nr_node *found = NULL;
47 struct nr_node *nr_node;
48
49 spin_lock_bh(&nr_node_list_lock);
50 nr_node_for_each(nr_node, &nr_node_list)
51 if (ax25cmp(callsign, &nr_node->callsign) == 0) {
52 nr_node_hold(nr_node);
53 found = nr_node;
54 break;
55 }
56 spin_unlock_bh(&nr_node_list_lock);
57 return found;
58}
59
60static struct nr_neigh *nr_neigh_get_dev(ax25_address *callsign,
61 struct net_device *dev)
62{
63 struct nr_neigh *found = NULL;
64 struct nr_neigh *nr_neigh;
65
66 spin_lock_bh(&nr_neigh_list_lock);
67 nr_neigh_for_each(nr_neigh, &nr_neigh_list)
68 if (ax25cmp(callsign, &nr_neigh->callsign) == 0 &&
69 nr_neigh->dev == dev) {
70 nr_neigh_hold(nr_neigh);
71 found = nr_neigh;
72 break;
73 }
74 spin_unlock_bh(&nr_neigh_list_lock);
75 return found;
76}
77
78static void nr_remove_neigh(struct nr_neigh *);
79
80/* re-sort the routes in quality order. */
81static void re_sort_routes(struct nr_node *nr_node, int x, int y)
82{
83 if (nr_node->routes[y].quality > nr_node->routes[x].quality) {
84 if (nr_node->which == x)
85 nr_node->which = y;
86 else if (nr_node->which == y)
87 nr_node->which = x;
88
89 swap(nr_node->routes[x], nr_node->routes[y]);
90 }
91}
92
93/*
94 * Add a new route to a node, and in the process add the node and the
95 * neighbour if it is new.
96 */
97static int __must_check nr_add_node(ax25_address *nr, const char *mnemonic,
98 ax25_address *ax25, ax25_digi *ax25_digi, struct net_device *dev,
99 int quality, int obs_count)
100{
101 struct nr_node *nr_node;
102 struct nr_neigh *nr_neigh;
103 int i, found;
104 struct net_device *odev;
105
106 if ((odev=nr_dev_get(nr)) != NULL) { /* Can't add routes to ourself */
107 dev_put(odev);
108 return -EINVAL;
109 }
110
111 nr_node = nr_node_get(nr);
112
113 nr_neigh = nr_neigh_get_dev(ax25, dev);
114
115 /*
116 * The L2 link to a neighbour has failed in the past
117 * and now a frame comes from this neighbour. We assume
118 * it was a temporary trouble with the link and reset the
119 * routes now (and not wait for a node broadcast).
120 */
121 if (nr_neigh != NULL && nr_neigh->failed != 0 && quality == 0) {
122 struct nr_node *nr_nodet;
123
124 spin_lock_bh(&nr_node_list_lock);
125 nr_node_for_each(nr_nodet, &nr_node_list) {
126 nr_node_lock(nr_nodet);
127 for (i = 0; i < nr_nodet->count; i++)
128 if (nr_nodet->routes[i].neighbour == nr_neigh)
129 if (i < nr_nodet->which)
130 nr_nodet->which = i;
131 nr_node_unlock(nr_nodet);
132 }
133 spin_unlock_bh(&nr_node_list_lock);
134 }
135
136 if (nr_neigh != NULL)
137 nr_neigh->failed = 0;
138
139 if (quality == 0 && nr_neigh != NULL && nr_node != NULL) {
140 nr_neigh_put(nr_neigh);
141 nr_node_put(nr_node);
142 return 0;
143 }
144
145 if (nr_neigh == NULL) {
146 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL) {
147 if (nr_node)
148 nr_node_put(nr_node);
149 return -ENOMEM;
150 }
151
152 nr_neigh->callsign = *ax25;
153 nr_neigh->digipeat = NULL;
154 nr_neigh->ax25 = NULL;
155 nr_neigh->dev = dev;
156 nr_neigh->quality = sysctl_netrom_default_path_quality;
157 nr_neigh->locked = 0;
158 nr_neigh->count = 0;
159 nr_neigh->number = nr_neigh_no++;
160 nr_neigh->failed = 0;
161 refcount_set(&nr_neigh->refcount, 1);
162
163 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
164 nr_neigh->digipeat = kmemdup(ax25_digi,
165 sizeof(*ax25_digi),
166 GFP_KERNEL);
167 if (nr_neigh->digipeat == NULL) {
168 kfree(nr_neigh);
169 if (nr_node)
170 nr_node_put(nr_node);
171 return -ENOMEM;
172 }
173 }
174
175 spin_lock_bh(&nr_neigh_list_lock);
176 hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
177 nr_neigh_hold(nr_neigh);
178 spin_unlock_bh(&nr_neigh_list_lock);
179 }
180
181 if (quality != 0 && ax25cmp(nr, ax25) == 0 && !nr_neigh->locked)
182 nr_neigh->quality = quality;
183
184 if (nr_node == NULL) {
185 if ((nr_node = kmalloc(sizeof(*nr_node), GFP_ATOMIC)) == NULL) {
186 if (nr_neigh)
187 nr_neigh_put(nr_neigh);
188 return -ENOMEM;
189 }
190
191 nr_node->callsign = *nr;
192 strcpy(nr_node->mnemonic, mnemonic);
193
194 nr_node->which = 0;
195 nr_node->count = 1;
196 refcount_set(&nr_node->refcount, 1);
197 spin_lock_init(&nr_node->node_lock);
198
199 nr_node->routes[0].quality = quality;
200 nr_node->routes[0].obs_count = obs_count;
201 nr_node->routes[0].neighbour = nr_neigh;
202
203 nr_neigh_hold(nr_neigh);
204 nr_neigh->count++;
205
206 spin_lock_bh(&nr_node_list_lock);
207 hlist_add_head(&nr_node->node_node, &nr_node_list);
208 /* refcount initialized at 1 */
209 spin_unlock_bh(&nr_node_list_lock);
210
211 return 0;
212 }
213 nr_node_lock(nr_node);
214
215 if (quality != 0)
216 strcpy(nr_node->mnemonic, mnemonic);
217
218 for (found = 0, i = 0; i < nr_node->count; i++) {
219 if (nr_node->routes[i].neighbour == nr_neigh) {
220 nr_node->routes[i].quality = quality;
221 nr_node->routes[i].obs_count = obs_count;
222 found = 1;
223 break;
224 }
225 }
226
227 if (!found) {
228 /* We have space at the bottom, slot it in */
229 if (nr_node->count < 3) {
230 nr_node->routes[2] = nr_node->routes[1];
231 nr_node->routes[1] = nr_node->routes[0];
232
233 nr_node->routes[0].quality = quality;
234 nr_node->routes[0].obs_count = obs_count;
235 nr_node->routes[0].neighbour = nr_neigh;
236
237 nr_node->which++;
238 nr_node->count++;
239 nr_neigh_hold(nr_neigh);
240 nr_neigh->count++;
241 } else {
242 /* It must be better than the worst */
243 if (quality > nr_node->routes[2].quality) {
244 nr_node->routes[2].neighbour->count--;
245 nr_neigh_put(nr_node->routes[2].neighbour);
246
247 if (nr_node->routes[2].neighbour->count == 0 && !nr_node->routes[2].neighbour->locked)
248 nr_remove_neigh(nr_node->routes[2].neighbour);
249
250 nr_node->routes[2].quality = quality;
251 nr_node->routes[2].obs_count = obs_count;
252 nr_node->routes[2].neighbour = nr_neigh;
253
254 nr_neigh_hold(nr_neigh);
255 nr_neigh->count++;
256 }
257 }
258 }
259
260 /* Now re-sort the routes in quality order */
261 switch (nr_node->count) {
262 case 3:
263 re_sort_routes(nr_node, 0, 1);
264 re_sort_routes(nr_node, 1, 2);
265 /* fall through */
266 case 2:
267 re_sort_routes(nr_node, 0, 1);
268 case 1:
269 break;
270 }
271
272 for (i = 0; i < nr_node->count; i++) {
273 if (nr_node->routes[i].neighbour == nr_neigh) {
274 if (i < nr_node->which)
275 nr_node->which = i;
276 break;
277 }
278 }
279
280 nr_neigh_put(nr_neigh);
281 nr_node_unlock(nr_node);
282 nr_node_put(nr_node);
283 return 0;
284}
285
286static inline void __nr_remove_node(struct nr_node *nr_node)
287{
288 hlist_del_init(&nr_node->node_node);
289 nr_node_put(nr_node);
290}
291
292#define nr_remove_node_locked(__node) \
293 __nr_remove_node(__node)
294
295static void nr_remove_node(struct nr_node *nr_node)
296{
297 spin_lock_bh(&nr_node_list_lock);
298 __nr_remove_node(nr_node);
299 spin_unlock_bh(&nr_node_list_lock);
300}
301
302static inline void __nr_remove_neigh(struct nr_neigh *nr_neigh)
303{
304 hlist_del_init(&nr_neigh->neigh_node);
305 nr_neigh_put(nr_neigh);
306}
307
308#define nr_remove_neigh_locked(__neigh) \
309 __nr_remove_neigh(__neigh)
310
311static void nr_remove_neigh(struct nr_neigh *nr_neigh)
312{
313 spin_lock_bh(&nr_neigh_list_lock);
314 __nr_remove_neigh(nr_neigh);
315 spin_unlock_bh(&nr_neigh_list_lock);
316}
317
318/*
319 * "Delete" a node. Strictly speaking remove a route to a node. The node
320 * is only deleted if no routes are left to it.
321 */
322static int nr_del_node(ax25_address *callsign, ax25_address *neighbour, struct net_device *dev)
323{
324 struct nr_node *nr_node;
325 struct nr_neigh *nr_neigh;
326 int i;
327
328 nr_node = nr_node_get(callsign);
329
330 if (nr_node == NULL)
331 return -EINVAL;
332
333 nr_neigh = nr_neigh_get_dev(neighbour, dev);
334
335 if (nr_neigh == NULL) {
336 nr_node_put(nr_node);
337 return -EINVAL;
338 }
339
340 nr_node_lock(nr_node);
341 for (i = 0; i < nr_node->count; i++) {
342 if (nr_node->routes[i].neighbour == nr_neigh) {
343 nr_neigh->count--;
344 nr_neigh_put(nr_neigh);
345
346 if (nr_neigh->count == 0 && !nr_neigh->locked)
347 nr_remove_neigh(nr_neigh);
348 nr_neigh_put(nr_neigh);
349
350 nr_node->count--;
351
352 if (nr_node->count == 0) {
353 nr_remove_node(nr_node);
354 } else {
355 switch (i) {
356 case 0:
357 nr_node->routes[0] = nr_node->routes[1];
358 /* fall through */
359 case 1:
360 nr_node->routes[1] = nr_node->routes[2];
361 case 2:
362 break;
363 }
364 nr_node_put(nr_node);
365 }
366 nr_node_unlock(nr_node);
367
368 return 0;
369 }
370 }
371 nr_neigh_put(nr_neigh);
372 nr_node_unlock(nr_node);
373 nr_node_put(nr_node);
374
375 return -EINVAL;
376}
377
378/*
379 * Lock a neighbour with a quality.
380 */
381static int __must_check nr_add_neigh(ax25_address *callsign,
382 ax25_digi *ax25_digi, struct net_device *dev, unsigned int quality)
383{
384 struct nr_neigh *nr_neigh;
385
386 nr_neigh = nr_neigh_get_dev(callsign, dev);
387 if (nr_neigh) {
388 nr_neigh->quality = quality;
389 nr_neigh->locked = 1;
390 nr_neigh_put(nr_neigh);
391 return 0;
392 }
393
394 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
395 return -ENOMEM;
396
397 nr_neigh->callsign = *callsign;
398 nr_neigh->digipeat = NULL;
399 nr_neigh->ax25 = NULL;
400 nr_neigh->dev = dev;
401 nr_neigh->quality = quality;
402 nr_neigh->locked = 1;
403 nr_neigh->count = 0;
404 nr_neigh->number = nr_neigh_no++;
405 nr_neigh->failed = 0;
406 refcount_set(&nr_neigh->refcount, 1);
407
408 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
409 nr_neigh->digipeat = kmemdup(ax25_digi, sizeof(*ax25_digi),
410 GFP_KERNEL);
411 if (nr_neigh->digipeat == NULL) {
412 kfree(nr_neigh);
413 return -ENOMEM;
414 }
415 }
416
417 spin_lock_bh(&nr_neigh_list_lock);
418 hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
419 /* refcount is initialized at 1 */
420 spin_unlock_bh(&nr_neigh_list_lock);
421
422 return 0;
423}
424
425/*
426 * "Delete" a neighbour. The neighbour is only removed if the number
427 * of nodes that may use it is zero.
428 */
429static int nr_del_neigh(ax25_address *callsign, struct net_device *dev, unsigned int quality)
430{
431 struct nr_neigh *nr_neigh;
432
433 nr_neigh = nr_neigh_get_dev(callsign, dev);
434
435 if (nr_neigh == NULL) return -EINVAL;
436
437 nr_neigh->quality = quality;
438 nr_neigh->locked = 0;
439
440 if (nr_neigh->count == 0)
441 nr_remove_neigh(nr_neigh);
442 nr_neigh_put(nr_neigh);
443
444 return 0;
445}
446
447/*
448 * Decrement the obsolescence count by one. If a route is reduced to a
449 * count of zero, remove it. Also remove any unlocked neighbours with
450 * zero nodes routing via it.
451 */
452static int nr_dec_obs(void)
453{
454 struct nr_neigh *nr_neigh;
455 struct nr_node *s;
456 struct hlist_node *nodet;
457 int i;
458
459 spin_lock_bh(&nr_node_list_lock);
460 nr_node_for_each_safe(s, nodet, &nr_node_list) {
461 nr_node_lock(s);
462 for (i = 0; i < s->count; i++) {
463 switch (s->routes[i].obs_count) {
464 case 0: /* A locked entry */
465 break;
466
467 case 1: /* From 1 -> 0 */
468 nr_neigh = s->routes[i].neighbour;
469
470 nr_neigh->count--;
471 nr_neigh_put(nr_neigh);
472
473 if (nr_neigh->count == 0 && !nr_neigh->locked)
474 nr_remove_neigh(nr_neigh);
475
476 s->count--;
477
478 switch (i) {
479 case 0:
480 s->routes[0] = s->routes[1];
481 /* Fallthrough */
482 case 1:
483 s->routes[1] = s->routes[2];
484 case 2:
485 break;
486 }
487 break;
488
489 default:
490 s->routes[i].obs_count--;
491 break;
492
493 }
494 }
495
496 if (s->count <= 0)
497 nr_remove_node_locked(s);
498 nr_node_unlock(s);
499 }
500 spin_unlock_bh(&nr_node_list_lock);
501
502 return 0;
503}
504
505/*
506 * A device has been removed. Remove its routes and neighbours.
507 */
508void nr_rt_device_down(struct net_device *dev)
509{
510 struct nr_neigh *s;
511 struct hlist_node *nodet, *node2t;
512 struct nr_node *t;
513 int i;
514
515 spin_lock_bh(&nr_neigh_list_lock);
516 nr_neigh_for_each_safe(s, nodet, &nr_neigh_list) {
517 if (s->dev == dev) {
518 spin_lock_bh(&nr_node_list_lock);
519 nr_node_for_each_safe(t, node2t, &nr_node_list) {
520 nr_node_lock(t);
521 for (i = 0; i < t->count; i++) {
522 if (t->routes[i].neighbour == s) {
523 t->count--;
524
525 switch (i) {
526 case 0:
527 t->routes[0] = t->routes[1];
528 /* fall through */
529 case 1:
530 t->routes[1] = t->routes[2];
531 case 2:
532 break;
533 }
534 }
535 }
536
537 if (t->count <= 0)
538 nr_remove_node_locked(t);
539 nr_node_unlock(t);
540 }
541 spin_unlock_bh(&nr_node_list_lock);
542
543 nr_remove_neigh_locked(s);
544 }
545 }
546 spin_unlock_bh(&nr_neigh_list_lock);
547}
548
549/*
550 * Check that the device given is a valid AX.25 interface that is "up".
551 * Or a valid ethernet interface with an AX.25 callsign binding.
552 */
553static struct net_device *nr_ax25_dev_get(char *devname)
554{
555 struct net_device *dev;
556
557 if ((dev = dev_get_by_name(&init_net, devname)) == NULL)
558 return NULL;
559
560 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
561 return dev;
562
563 dev_put(dev);
564 return NULL;
565}
566
567/*
568 * Find the first active NET/ROM device, usually "nr0".
569 */
570struct net_device *nr_dev_first(void)
571{
572 struct net_device *dev, *first = NULL;
573
574 rcu_read_lock();
575 for_each_netdev_rcu(&init_net, dev) {
576 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM)
577 if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
578 first = dev;
579 }
580 if (first)
581 dev_hold(first);
582 rcu_read_unlock();
583
584 return first;
585}
586
587/*
588 * Find the NET/ROM device for the given callsign.
589 */
590struct net_device *nr_dev_get(ax25_address *addr)
591{
592 struct net_device *dev;
593
594 rcu_read_lock();
595 for_each_netdev_rcu(&init_net, dev) {
596 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM &&
597 ax25cmp(addr, (ax25_address *)dev->dev_addr) == 0) {
598 dev_hold(dev);
599 goto out;
600 }
601 }
602 dev = NULL;
603out:
604 rcu_read_unlock();
605 return dev;
606}
607
608static ax25_digi *nr_call_to_digi(ax25_digi *digi, int ndigis,
609 ax25_address *digipeaters)
610{
611 int i;
612
613 if (ndigis == 0)
614 return NULL;
615
616 for (i = 0; i < ndigis; i++) {
617 digi->calls[i] = digipeaters[i];
618 digi->repeated[i] = 0;
619 }
620
621 digi->ndigi = ndigis;
622 digi->lastrepeat = -1;
623
624 return digi;
625}
626
627/*
628 * Handle the ioctls that control the routing functions.
629 */
630int nr_rt_ioctl(unsigned int cmd, void __user *arg)
631{
632 struct nr_route_struct nr_route;
633 struct net_device *dev;
634 ax25_digi digi;
635 int ret;
636
637 switch (cmd) {
638 case SIOCADDRT:
639 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
640 return -EFAULT;
641 if (nr_route.ndigis > AX25_MAX_DIGIS)
642 return -EINVAL;
643 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
644 return -EINVAL;
645 switch (nr_route.type) {
646 case NETROM_NODE:
647 if (strnlen(nr_route.mnemonic, 7) == 7) {
648 ret = -EINVAL;
649 break;
650 }
651
652 ret = nr_add_node(&nr_route.callsign,
653 nr_route.mnemonic,
654 &nr_route.neighbour,
655 nr_call_to_digi(&digi, nr_route.ndigis,
656 nr_route.digipeaters),
657 dev, nr_route.quality,
658 nr_route.obs_count);
659 break;
660 case NETROM_NEIGH:
661 ret = nr_add_neigh(&nr_route.callsign,
662 nr_call_to_digi(&digi, nr_route.ndigis,
663 nr_route.digipeaters),
664 dev, nr_route.quality);
665 break;
666 default:
667 ret = -EINVAL;
668 }
669 dev_put(dev);
670 return ret;
671
672 case SIOCDELRT:
673 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
674 return -EFAULT;
675 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
676 return -EINVAL;
677 switch (nr_route.type) {
678 case NETROM_NODE:
679 ret = nr_del_node(&nr_route.callsign,
680 &nr_route.neighbour, dev);
681 break;
682 case NETROM_NEIGH:
683 ret = nr_del_neigh(&nr_route.callsign,
684 dev, nr_route.quality);
685 break;
686 default:
687 ret = -EINVAL;
688 }
689 dev_put(dev);
690 return ret;
691
692 case SIOCNRDECOBS:
693 return nr_dec_obs();
694
695 default:
696 return -EINVAL;
697 }
698
699 return 0;
700}
701
702/*
703 * A level 2 link has timed out, therefore it appears to be a poor link,
704 * then don't use that neighbour until it is reset.
705 */
706void nr_link_failed(ax25_cb *ax25, int reason)
707{
708 struct nr_neigh *s, *nr_neigh = NULL;
709 struct nr_node *nr_node = NULL;
710
711 spin_lock_bh(&nr_neigh_list_lock);
712 nr_neigh_for_each(s, &nr_neigh_list) {
713 if (s->ax25 == ax25) {
714 nr_neigh_hold(s);
715 nr_neigh = s;
716 break;
717 }
718 }
719 spin_unlock_bh(&nr_neigh_list_lock);
720
721 if (nr_neigh == NULL)
722 return;
723
724 nr_neigh->ax25 = NULL;
725 ax25_cb_put(ax25);
726
727 if (++nr_neigh->failed < sysctl_netrom_link_fails_count) {
728 nr_neigh_put(nr_neigh);
729 return;
730 }
731 spin_lock_bh(&nr_node_list_lock);
732 nr_node_for_each(nr_node, &nr_node_list) {
733 nr_node_lock(nr_node);
734 if (nr_node->which < nr_node->count &&
735 nr_node->routes[nr_node->which].neighbour == nr_neigh)
736 nr_node->which++;
737 nr_node_unlock(nr_node);
738 }
739 spin_unlock_bh(&nr_node_list_lock);
740 nr_neigh_put(nr_neigh);
741}
742
743/*
744 * Route a frame to an appropriate AX.25 connection. A NULL ax25_cb
745 * indicates an internally generated frame.
746 */
747int nr_route_frame(struct sk_buff *skb, ax25_cb *ax25)
748{
749 ax25_address *nr_src, *nr_dest;
750 struct nr_neigh *nr_neigh;
751 struct nr_node *nr_node;
752 struct net_device *dev;
753 unsigned char *dptr;
754 ax25_cb *ax25s;
755 int ret;
756 struct sk_buff *skbn;
757
758
759 nr_src = (ax25_address *)(skb->data + 0);
760 nr_dest = (ax25_address *)(skb->data + 7);
761
762 if (ax25 != NULL) {
763 ret = nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
764 ax25->ax25_dev->dev, 0,
765 sysctl_netrom_obsolescence_count_initialiser);
766 if (ret)
767 return ret;
768 }
769
770 if ((dev = nr_dev_get(nr_dest)) != NULL) { /* Its for me */
771 if (ax25 == NULL) /* Its from me */
772 ret = nr_loopback_queue(skb);
773 else
774 ret = nr_rx_frame(skb, dev);
775 dev_put(dev);
776 return ret;
777 }
778
779 if (!sysctl_netrom_routing_control && ax25 != NULL)
780 return 0;
781
782 /* Its Time-To-Live has expired */
783 if (skb->data[14] == 1) {
784 return 0;
785 }
786
787 nr_node = nr_node_get(nr_dest);
788 if (nr_node == NULL)
789 return 0;
790 nr_node_lock(nr_node);
791
792 if (nr_node->which >= nr_node->count) {
793 nr_node_unlock(nr_node);
794 nr_node_put(nr_node);
795 return 0;
796 }
797
798 nr_neigh = nr_node->routes[nr_node->which].neighbour;
799
800 if ((dev = nr_dev_first()) == NULL) {
801 nr_node_unlock(nr_node);
802 nr_node_put(nr_node);
803 return 0;
804 }
805
806 /* We are going to change the netrom headers so we should get our
807 own skb, we also did not know until now how much header space
808 we had to reserve... - RXQ */
809 if ((skbn=skb_copy_expand(skb, dev->hard_header_len, 0, GFP_ATOMIC)) == NULL) {
810 nr_node_unlock(nr_node);
811 nr_node_put(nr_node);
812 dev_put(dev);
813 return 0;
814 }
815 kfree_skb(skb);
816 skb=skbn;
817 skb->data[14]--;
818
819 dptr = skb_push(skb, 1);
820 *dptr = AX25_P_NETROM;
821
822 ax25s = nr_neigh->ax25;
823 nr_neigh->ax25 = ax25_send_frame(skb, 256,
824 (ax25_address *)dev->dev_addr,
825 &nr_neigh->callsign,
826 nr_neigh->digipeat, nr_neigh->dev);
827 if (ax25s)
828 ax25_cb_put(ax25s);
829
830 dev_put(dev);
831 ret = (nr_neigh->ax25 != NULL);
832 nr_node_unlock(nr_node);
833 nr_node_put(nr_node);
834
835 return ret;
836}
837
838#ifdef CONFIG_PROC_FS
839
840static void *nr_node_start(struct seq_file *seq, loff_t *pos)
841{
842 spin_lock_bh(&nr_node_list_lock);
843 return seq_hlist_start_head(&nr_node_list, *pos);
844}
845
846static void *nr_node_next(struct seq_file *seq, void *v, loff_t *pos)
847{
848 return seq_hlist_next(v, &nr_node_list, pos);
849}
850
851static void nr_node_stop(struct seq_file *seq, void *v)
852{
853 spin_unlock_bh(&nr_node_list_lock);
854}
855
856static int nr_node_show(struct seq_file *seq, void *v)
857{
858 char buf[11];
859 int i;
860
861 if (v == SEQ_START_TOKEN)
862 seq_puts(seq,
863 "callsign mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
864 else {
865 struct nr_node *nr_node = hlist_entry(v, struct nr_node,
866 node_node);
867
868 nr_node_lock(nr_node);
869 seq_printf(seq, "%-9s %-7s %d %d",
870 ax2asc(buf, &nr_node->callsign),
871 (nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
872 nr_node->which + 1,
873 nr_node->count);
874
875 for (i = 0; i < nr_node->count; i++) {
876 seq_printf(seq, " %3d %d %05d",
877 nr_node->routes[i].quality,
878 nr_node->routes[i].obs_count,
879 nr_node->routes[i].neighbour->number);
880 }
881 nr_node_unlock(nr_node);
882
883 seq_puts(seq, "\n");
884 }
885 return 0;
886}
887
888const struct seq_operations nr_node_seqops = {
889 .start = nr_node_start,
890 .next = nr_node_next,
891 .stop = nr_node_stop,
892 .show = nr_node_show,
893};
894
895static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
896{
897 spin_lock_bh(&nr_neigh_list_lock);
898 return seq_hlist_start_head(&nr_neigh_list, *pos);
899}
900
901static void *nr_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
902{
903 return seq_hlist_next(v, &nr_neigh_list, pos);
904}
905
906static void nr_neigh_stop(struct seq_file *seq, void *v)
907{
908 spin_unlock_bh(&nr_neigh_list_lock);
909}
910
911static int nr_neigh_show(struct seq_file *seq, void *v)
912{
913 char buf[11];
914 int i;
915
916 if (v == SEQ_START_TOKEN)
917 seq_puts(seq, "addr callsign dev qual lock count failed digipeaters\n");
918 else {
919 struct nr_neigh *nr_neigh;
920
921 nr_neigh = hlist_entry(v, struct nr_neigh, neigh_node);
922 seq_printf(seq, "%05d %-9s %-4s %3d %d %3d %3d",
923 nr_neigh->number,
924 ax2asc(buf, &nr_neigh->callsign),
925 nr_neigh->dev ? nr_neigh->dev->name : "???",
926 nr_neigh->quality,
927 nr_neigh->locked,
928 nr_neigh->count,
929 nr_neigh->failed);
930
931 if (nr_neigh->digipeat != NULL) {
932 for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
933 seq_printf(seq, " %s",
934 ax2asc(buf, &nr_neigh->digipeat->calls[i]));
935 }
936
937 seq_puts(seq, "\n");
938 }
939 return 0;
940}
941
942const struct seq_operations nr_neigh_seqops = {
943 .start = nr_neigh_start,
944 .next = nr_neigh_next,
945 .stop = nr_neigh_stop,
946 .show = nr_neigh_show,
947};
948#endif
949
950/*
951 * Free all memory associated with the nodes and routes lists.
952 */
953void nr_rt_free(void)
954{
955 struct nr_neigh *s = NULL;
956 struct nr_node *t = NULL;
957 struct hlist_node *nodet;
958
959 spin_lock_bh(&nr_neigh_list_lock);
960 spin_lock_bh(&nr_node_list_lock);
961 nr_node_for_each_safe(t, nodet, &nr_node_list) {
962 nr_node_lock(t);
963 nr_remove_node_locked(t);
964 nr_node_unlock(t);
965 }
966 nr_neigh_for_each_safe(s, nodet, &nr_neigh_list) {
967 while(s->count) {
968 s->count--;
969 nr_neigh_put(s);
970 }
971 nr_remove_neigh_locked(s);
972 }
973 spin_unlock_bh(&nr_node_list_lock);
974 spin_unlock_bh(&nr_neigh_list_lock);
975}