xref: /openbmc/linux/net/netrom/nr_route.c (revision 0a94608f)
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 
37 static unsigned int nr_neigh_no = 1;
38 
39 static HLIST_HEAD(nr_node_list);
40 static DEFINE_SPINLOCK(nr_node_list_lock);
41 static HLIST_HEAD(nr_neigh_list);
42 static DEFINE_SPINLOCK(nr_neigh_list_lock);
43 
44 static 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 
60 static 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 
78 static void nr_remove_neigh(struct nr_neigh *);
79 
80 /*      re-sort the routes in quality order.    */
81 static 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  */
97 static 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 		nr_neigh_put(nr_neigh);
212 		return 0;
213 	}
214 	nr_node_lock(nr_node);
215 
216 	if (quality != 0)
217 		strcpy(nr_node->mnemonic, mnemonic);
218 
219 	for (found = 0, i = 0; i < nr_node->count; i++) {
220 		if (nr_node->routes[i].neighbour == nr_neigh) {
221 			nr_node->routes[i].quality   = quality;
222 			nr_node->routes[i].obs_count = obs_count;
223 			found = 1;
224 			break;
225 		}
226 	}
227 
228 	if (!found) {
229 		/* We have space at the bottom, slot it in */
230 		if (nr_node->count < 3) {
231 			nr_node->routes[2] = nr_node->routes[1];
232 			nr_node->routes[1] = nr_node->routes[0];
233 
234 			nr_node->routes[0].quality   = quality;
235 			nr_node->routes[0].obs_count = obs_count;
236 			nr_node->routes[0].neighbour = nr_neigh;
237 
238 			nr_node->which++;
239 			nr_node->count++;
240 			nr_neigh_hold(nr_neigh);
241 			nr_neigh->count++;
242 		} else {
243 			/* It must be better than the worst */
244 			if (quality > nr_node->routes[2].quality) {
245 				nr_node->routes[2].neighbour->count--;
246 				nr_neigh_put(nr_node->routes[2].neighbour);
247 
248 				if (nr_node->routes[2].neighbour->count == 0 && !nr_node->routes[2].neighbour->locked)
249 					nr_remove_neigh(nr_node->routes[2].neighbour);
250 
251 				nr_node->routes[2].quality   = quality;
252 				nr_node->routes[2].obs_count = obs_count;
253 				nr_node->routes[2].neighbour = nr_neigh;
254 
255 				nr_neigh_hold(nr_neigh);
256 				nr_neigh->count++;
257 			}
258 		}
259 	}
260 
261 	/* Now re-sort the routes in quality order */
262 	switch (nr_node->count) {
263 	case 3:
264 		re_sort_routes(nr_node, 0, 1);
265 		re_sort_routes(nr_node, 1, 2);
266 		fallthrough;
267 	case 2:
268 		re_sort_routes(nr_node, 0, 1);
269 		break;
270 	case 1:
271 		break;
272 	}
273 
274 	for (i = 0; i < nr_node->count; i++) {
275 		if (nr_node->routes[i].neighbour == nr_neigh) {
276 			if (i < nr_node->which)
277 				nr_node->which = i;
278 			break;
279 		}
280 	}
281 
282 	nr_neigh_put(nr_neigh);
283 	nr_node_unlock(nr_node);
284 	nr_node_put(nr_node);
285 	return 0;
286 }
287 
288 static inline void __nr_remove_node(struct nr_node *nr_node)
289 {
290 	hlist_del_init(&nr_node->node_node);
291 	nr_node_put(nr_node);
292 }
293 
294 #define nr_remove_node_locked(__node) \
295 	__nr_remove_node(__node)
296 
297 static void nr_remove_node(struct nr_node *nr_node)
298 {
299 	spin_lock_bh(&nr_node_list_lock);
300 	__nr_remove_node(nr_node);
301 	spin_unlock_bh(&nr_node_list_lock);
302 }
303 
304 static inline void __nr_remove_neigh(struct nr_neigh *nr_neigh)
305 {
306 	hlist_del_init(&nr_neigh->neigh_node);
307 	nr_neigh_put(nr_neigh);
308 }
309 
310 #define nr_remove_neigh_locked(__neigh) \
311 	__nr_remove_neigh(__neigh)
312 
313 static void nr_remove_neigh(struct nr_neigh *nr_neigh)
314 {
315 	spin_lock_bh(&nr_neigh_list_lock);
316 	__nr_remove_neigh(nr_neigh);
317 	spin_unlock_bh(&nr_neigh_list_lock);
318 }
319 
320 /*
321  *	"Delete" a node. Strictly speaking remove a route to a node. The node
322  *	is only deleted if no routes are left to it.
323  */
324 static int nr_del_node(ax25_address *callsign, ax25_address *neighbour, struct net_device *dev)
325 {
326 	struct nr_node  *nr_node;
327 	struct nr_neigh *nr_neigh;
328 	int i;
329 
330 	nr_node = nr_node_get(callsign);
331 
332 	if (nr_node == NULL)
333 		return -EINVAL;
334 
335 	nr_neigh = nr_neigh_get_dev(neighbour, dev);
336 
337 	if (nr_neigh == NULL) {
338 		nr_node_put(nr_node);
339 		return -EINVAL;
340 	}
341 
342 	nr_node_lock(nr_node);
343 	for (i = 0; i < nr_node->count; i++) {
344 		if (nr_node->routes[i].neighbour == nr_neigh) {
345 			nr_neigh->count--;
346 			nr_neigh_put(nr_neigh);
347 
348 			if (nr_neigh->count == 0 && !nr_neigh->locked)
349 				nr_remove_neigh(nr_neigh);
350 			nr_neigh_put(nr_neigh);
351 
352 			nr_node->count--;
353 
354 			if (nr_node->count == 0) {
355 				nr_remove_node(nr_node);
356 			} else {
357 				switch (i) {
358 				case 0:
359 					nr_node->routes[0] = nr_node->routes[1];
360 					fallthrough;
361 				case 1:
362 					nr_node->routes[1] = nr_node->routes[2];
363 					fallthrough;
364 				case 2:
365 					break;
366 				}
367 				nr_node_put(nr_node);
368 			}
369 			nr_node_unlock(nr_node);
370 
371 			return 0;
372 		}
373 	}
374 	nr_neigh_put(nr_neigh);
375 	nr_node_unlock(nr_node);
376 	nr_node_put(nr_node);
377 
378 	return -EINVAL;
379 }
380 
381 /*
382  *	Lock a neighbour with a quality.
383  */
384 static int __must_check nr_add_neigh(ax25_address *callsign,
385 	ax25_digi *ax25_digi, struct net_device *dev, unsigned int quality)
386 {
387 	struct nr_neigh *nr_neigh;
388 
389 	nr_neigh = nr_neigh_get_dev(callsign, dev);
390 	if (nr_neigh) {
391 		nr_neigh->quality = quality;
392 		nr_neigh->locked  = 1;
393 		nr_neigh_put(nr_neigh);
394 		return 0;
395 	}
396 
397 	if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
398 		return -ENOMEM;
399 
400 	nr_neigh->callsign = *callsign;
401 	nr_neigh->digipeat = NULL;
402 	nr_neigh->ax25     = NULL;
403 	nr_neigh->dev      = dev;
404 	nr_neigh->quality  = quality;
405 	nr_neigh->locked   = 1;
406 	nr_neigh->count    = 0;
407 	nr_neigh->number   = nr_neigh_no++;
408 	nr_neigh->failed   = 0;
409 	refcount_set(&nr_neigh->refcount, 1);
410 
411 	if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
412 		nr_neigh->digipeat = kmemdup(ax25_digi, sizeof(*ax25_digi),
413 					     GFP_KERNEL);
414 		if (nr_neigh->digipeat == NULL) {
415 			kfree(nr_neigh);
416 			return -ENOMEM;
417 		}
418 	}
419 
420 	spin_lock_bh(&nr_neigh_list_lock);
421 	hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
422 	/* refcount is initialized at 1 */
423 	spin_unlock_bh(&nr_neigh_list_lock);
424 
425 	return 0;
426 }
427 
428 /*
429  *	"Delete" a neighbour. The neighbour is only removed if the number
430  *	of nodes that may use it is zero.
431  */
432 static int nr_del_neigh(ax25_address *callsign, struct net_device *dev, unsigned int quality)
433 {
434 	struct nr_neigh *nr_neigh;
435 
436 	nr_neigh = nr_neigh_get_dev(callsign, dev);
437 
438 	if (nr_neigh == NULL) return -EINVAL;
439 
440 	nr_neigh->quality = quality;
441 	nr_neigh->locked  = 0;
442 
443 	if (nr_neigh->count == 0)
444 		nr_remove_neigh(nr_neigh);
445 	nr_neigh_put(nr_neigh);
446 
447 	return 0;
448 }
449 
450 /*
451  *	Decrement the obsolescence count by one. If a route is reduced to a
452  *	count of zero, remove it. Also remove any unlocked neighbours with
453  *	zero nodes routing via it.
454  */
455 static int nr_dec_obs(void)
456 {
457 	struct nr_neigh *nr_neigh;
458 	struct nr_node  *s;
459 	struct hlist_node *nodet;
460 	int i;
461 
462 	spin_lock_bh(&nr_node_list_lock);
463 	nr_node_for_each_safe(s, nodet, &nr_node_list) {
464 		nr_node_lock(s);
465 		for (i = 0; i < s->count; i++) {
466 			switch (s->routes[i].obs_count) {
467 			case 0:		/* A locked entry */
468 				break;
469 
470 			case 1:		/* From 1 -> 0 */
471 				nr_neigh = s->routes[i].neighbour;
472 
473 				nr_neigh->count--;
474 				nr_neigh_put(nr_neigh);
475 
476 				if (nr_neigh->count == 0 && !nr_neigh->locked)
477 					nr_remove_neigh(nr_neigh);
478 
479 				s->count--;
480 
481 				switch (i) {
482 				case 0:
483 					s->routes[0] = s->routes[1];
484 					fallthrough;
485 				case 1:
486 					s->routes[1] = s->routes[2];
487 					break;
488 				case 2:
489 					break;
490 				}
491 				break;
492 
493 			default:
494 				s->routes[i].obs_count--;
495 				break;
496 
497 			}
498 		}
499 
500 		if (s->count <= 0)
501 			nr_remove_node_locked(s);
502 		nr_node_unlock(s);
503 	}
504 	spin_unlock_bh(&nr_node_list_lock);
505 
506 	return 0;
507 }
508 
509 /*
510  *	A device has been removed. Remove its routes and neighbours.
511  */
512 void nr_rt_device_down(struct net_device *dev)
513 {
514 	struct nr_neigh *s;
515 	struct hlist_node *nodet, *node2t;
516 	struct nr_node  *t;
517 	int i;
518 
519 	spin_lock_bh(&nr_neigh_list_lock);
520 	nr_neigh_for_each_safe(s, nodet, &nr_neigh_list) {
521 		if (s->dev == dev) {
522 			spin_lock_bh(&nr_node_list_lock);
523 			nr_node_for_each_safe(t, node2t, &nr_node_list) {
524 				nr_node_lock(t);
525 				for (i = 0; i < t->count; i++) {
526 					if (t->routes[i].neighbour == s) {
527 						t->count--;
528 
529 						switch (i) {
530 						case 0:
531 							t->routes[0] = t->routes[1];
532 							fallthrough;
533 						case 1:
534 							t->routes[1] = t->routes[2];
535 							break;
536 						case 2:
537 							break;
538 						}
539 					}
540 				}
541 
542 				if (t->count <= 0)
543 					nr_remove_node_locked(t);
544 				nr_node_unlock(t);
545 			}
546 			spin_unlock_bh(&nr_node_list_lock);
547 
548 			nr_remove_neigh_locked(s);
549 		}
550 	}
551 	spin_unlock_bh(&nr_neigh_list_lock);
552 }
553 
554 /*
555  *	Check that the device given is a valid AX.25 interface that is "up".
556  *	Or a valid ethernet interface with an AX.25 callsign binding.
557  */
558 static struct net_device *nr_ax25_dev_get(char *devname)
559 {
560 	struct net_device *dev;
561 
562 	if ((dev = dev_get_by_name(&init_net, devname)) == NULL)
563 		return NULL;
564 
565 	if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
566 		return dev;
567 
568 	dev_put(dev);
569 	return NULL;
570 }
571 
572 /*
573  *	Find the first active NET/ROM device, usually "nr0".
574  */
575 struct net_device *nr_dev_first(void)
576 {
577 	struct net_device *dev, *first = NULL;
578 
579 	rcu_read_lock();
580 	for_each_netdev_rcu(&init_net, dev) {
581 		if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM)
582 			if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
583 				first = dev;
584 	}
585 	dev_hold(first);
586 	rcu_read_unlock();
587 
588 	return first;
589 }
590 
591 /*
592  *	Find the NET/ROM device for the given callsign.
593  */
594 struct net_device *nr_dev_get(ax25_address *addr)
595 {
596 	struct net_device *dev;
597 
598 	rcu_read_lock();
599 	for_each_netdev_rcu(&init_net, dev) {
600 		if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM &&
601 		    ax25cmp(addr, (const ax25_address *)dev->dev_addr) == 0) {
602 			dev_hold(dev);
603 			goto out;
604 		}
605 	}
606 	dev = NULL;
607 out:
608 	rcu_read_unlock();
609 	return dev;
610 }
611 
612 static ax25_digi *nr_call_to_digi(ax25_digi *digi, int ndigis,
613 	ax25_address *digipeaters)
614 {
615 	int i;
616 
617 	if (ndigis == 0)
618 		return NULL;
619 
620 	for (i = 0; i < ndigis; i++) {
621 		digi->calls[i]    = digipeaters[i];
622 		digi->repeated[i] = 0;
623 	}
624 
625 	digi->ndigi      = ndigis;
626 	digi->lastrepeat = -1;
627 
628 	return digi;
629 }
630 
631 /*
632  *	Handle the ioctls that control the routing functions.
633  */
634 int nr_rt_ioctl(unsigned int cmd, void __user *arg)
635 {
636 	struct nr_route_struct nr_route;
637 	struct net_device *dev;
638 	ax25_digi digi;
639 	int ret;
640 
641 	switch (cmd) {
642 	case SIOCADDRT:
643 		if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
644 			return -EFAULT;
645 		if (nr_route.ndigis > AX25_MAX_DIGIS)
646 			return -EINVAL;
647 		if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
648 			return -EINVAL;
649 		switch (nr_route.type) {
650 		case NETROM_NODE:
651 			if (strnlen(nr_route.mnemonic, 7) == 7) {
652 				ret = -EINVAL;
653 				break;
654 			}
655 
656 			ret = nr_add_node(&nr_route.callsign,
657 				nr_route.mnemonic,
658 				&nr_route.neighbour,
659 				nr_call_to_digi(&digi, nr_route.ndigis,
660 						nr_route.digipeaters),
661 				dev, nr_route.quality,
662 				nr_route.obs_count);
663 			break;
664 		case NETROM_NEIGH:
665 			ret = nr_add_neigh(&nr_route.callsign,
666 				nr_call_to_digi(&digi, nr_route.ndigis,
667 						nr_route.digipeaters),
668 				dev, nr_route.quality);
669 			break;
670 		default:
671 			ret = -EINVAL;
672 		}
673 		dev_put(dev);
674 		return ret;
675 
676 	case SIOCDELRT:
677 		if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
678 			return -EFAULT;
679 		if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
680 			return -EINVAL;
681 		switch (nr_route.type) {
682 		case NETROM_NODE:
683 			ret = nr_del_node(&nr_route.callsign,
684 				&nr_route.neighbour, dev);
685 			break;
686 		case NETROM_NEIGH:
687 			ret = nr_del_neigh(&nr_route.callsign,
688 				dev, nr_route.quality);
689 			break;
690 		default:
691 			ret = -EINVAL;
692 		}
693 		dev_put(dev);
694 		return ret;
695 
696 	case SIOCNRDECOBS:
697 		return nr_dec_obs();
698 
699 	default:
700 		return -EINVAL;
701 	}
702 
703 	return 0;
704 }
705 
706 /*
707  * 	A level 2 link has timed out, therefore it appears to be a poor link,
708  *	then don't use that neighbour until it is reset.
709  */
710 void nr_link_failed(ax25_cb *ax25, int reason)
711 {
712 	struct nr_neigh *s, *nr_neigh = NULL;
713 	struct nr_node  *nr_node = NULL;
714 
715 	spin_lock_bh(&nr_neigh_list_lock);
716 	nr_neigh_for_each(s, &nr_neigh_list) {
717 		if (s->ax25 == ax25) {
718 			nr_neigh_hold(s);
719 			nr_neigh = s;
720 			break;
721 		}
722 	}
723 	spin_unlock_bh(&nr_neigh_list_lock);
724 
725 	if (nr_neigh == NULL)
726 		return;
727 
728 	nr_neigh->ax25 = NULL;
729 	ax25_cb_put(ax25);
730 
731 	if (++nr_neigh->failed < sysctl_netrom_link_fails_count) {
732 		nr_neigh_put(nr_neigh);
733 		return;
734 	}
735 	spin_lock_bh(&nr_node_list_lock);
736 	nr_node_for_each(nr_node, &nr_node_list) {
737 		nr_node_lock(nr_node);
738 		if (nr_node->which < nr_node->count &&
739 		    nr_node->routes[nr_node->which].neighbour == nr_neigh)
740 			nr_node->which++;
741 		nr_node_unlock(nr_node);
742 	}
743 	spin_unlock_bh(&nr_node_list_lock);
744 	nr_neigh_put(nr_neigh);
745 }
746 
747 /*
748  *	Route a frame to an appropriate AX.25 connection. A NULL ax25_cb
749  *	indicates an internally generated frame.
750  */
751 int nr_route_frame(struct sk_buff *skb, ax25_cb *ax25)
752 {
753 	ax25_address *nr_src, *nr_dest;
754 	struct nr_neigh *nr_neigh;
755 	struct nr_node  *nr_node;
756 	struct net_device *dev;
757 	unsigned char *dptr;
758 	ax25_cb *ax25s;
759 	int ret;
760 	struct sk_buff *skbn;
761 
762 
763 	nr_src  = (ax25_address *)(skb->data + 0);
764 	nr_dest = (ax25_address *)(skb->data + 7);
765 
766 	if (ax25 != NULL) {
767 		ret = nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
768 				  ax25->ax25_dev->dev, 0,
769 				  sysctl_netrom_obsolescence_count_initialiser);
770 		if (ret)
771 			return ret;
772 	}
773 
774 	if ((dev = nr_dev_get(nr_dest)) != NULL) {	/* Its for me */
775 		if (ax25 == NULL)			/* Its from me */
776 			ret = nr_loopback_queue(skb);
777 		else
778 			ret = nr_rx_frame(skb, dev);
779 		dev_put(dev);
780 		return ret;
781 	}
782 
783 	if (!sysctl_netrom_routing_control && ax25 != NULL)
784 		return 0;
785 
786 	/* Its Time-To-Live has expired */
787 	if (skb->data[14] == 1) {
788 		return 0;
789 	}
790 
791 	nr_node = nr_node_get(nr_dest);
792 	if (nr_node == NULL)
793 		return 0;
794 	nr_node_lock(nr_node);
795 
796 	if (nr_node->which >= nr_node->count) {
797 		nr_node_unlock(nr_node);
798 		nr_node_put(nr_node);
799 		return 0;
800 	}
801 
802 	nr_neigh = nr_node->routes[nr_node->which].neighbour;
803 
804 	if ((dev = nr_dev_first()) == NULL) {
805 		nr_node_unlock(nr_node);
806 		nr_node_put(nr_node);
807 		return 0;
808 	}
809 
810 	/* We are going to change the netrom headers so we should get our
811 	   own skb, we also did not know until now how much header space
812 	   we had to reserve... - RXQ */
813 	if ((skbn=skb_copy_expand(skb, dev->hard_header_len, 0, GFP_ATOMIC)) == NULL) {
814 		nr_node_unlock(nr_node);
815 		nr_node_put(nr_node);
816 		dev_put(dev);
817 		return 0;
818 	}
819 	kfree_skb(skb);
820 	skb=skbn;
821 	skb->data[14]--;
822 
823 	dptr  = skb_push(skb, 1);
824 	*dptr = AX25_P_NETROM;
825 
826 	ax25s = nr_neigh->ax25;
827 	nr_neigh->ax25 = ax25_send_frame(skb, 256,
828 					 (const ax25_address *)dev->dev_addr,
829 					 &nr_neigh->callsign,
830 					 nr_neigh->digipeat, nr_neigh->dev);
831 	if (ax25s)
832 		ax25_cb_put(ax25s);
833 
834 	dev_put(dev);
835 	ret = (nr_neigh->ax25 != NULL);
836 	nr_node_unlock(nr_node);
837 	nr_node_put(nr_node);
838 
839 	return ret;
840 }
841 
842 #ifdef CONFIG_PROC_FS
843 
844 static void *nr_node_start(struct seq_file *seq, loff_t *pos)
845 	__acquires(&nr_node_list_lock)
846 {
847 	spin_lock_bh(&nr_node_list_lock);
848 	return seq_hlist_start_head(&nr_node_list, *pos);
849 }
850 
851 static void *nr_node_next(struct seq_file *seq, void *v, loff_t *pos)
852 {
853 	return seq_hlist_next(v, &nr_node_list, pos);
854 }
855 
856 static void nr_node_stop(struct seq_file *seq, void *v)
857 	__releases(&nr_node_list_lock)
858 {
859 	spin_unlock_bh(&nr_node_list_lock);
860 }
861 
862 static int nr_node_show(struct seq_file *seq, void *v)
863 {
864 	char buf[11];
865 	int i;
866 
867 	if (v == SEQ_START_TOKEN)
868 		seq_puts(seq,
869 			 "callsign  mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
870 	else {
871 		struct nr_node *nr_node = hlist_entry(v, struct nr_node,
872 						      node_node);
873 
874 		nr_node_lock(nr_node);
875 		seq_printf(seq, "%-9s %-7s  %d %d",
876 			ax2asc(buf, &nr_node->callsign),
877 			(nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
878 			nr_node->which + 1,
879 			nr_node->count);
880 
881 		for (i = 0; i < nr_node->count; i++) {
882 			seq_printf(seq, "  %3d   %d %05d",
883 				nr_node->routes[i].quality,
884 				nr_node->routes[i].obs_count,
885 				nr_node->routes[i].neighbour->number);
886 		}
887 		nr_node_unlock(nr_node);
888 
889 		seq_puts(seq, "\n");
890 	}
891 	return 0;
892 }
893 
894 const struct seq_operations nr_node_seqops = {
895 	.start = nr_node_start,
896 	.next = nr_node_next,
897 	.stop = nr_node_stop,
898 	.show = nr_node_show,
899 };
900 
901 static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
902 	__acquires(&nr_neigh_list_lock)
903 {
904 	spin_lock_bh(&nr_neigh_list_lock);
905 	return seq_hlist_start_head(&nr_neigh_list, *pos);
906 }
907 
908 static void *nr_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
909 {
910 	return seq_hlist_next(v, &nr_neigh_list, pos);
911 }
912 
913 static void nr_neigh_stop(struct seq_file *seq, void *v)
914 	__releases(&nr_neigh_list_lock)
915 {
916 	spin_unlock_bh(&nr_neigh_list_lock);
917 }
918 
919 static int nr_neigh_show(struct seq_file *seq, void *v)
920 {
921 	char buf[11];
922 	int i;
923 
924 	if (v == SEQ_START_TOKEN)
925 		seq_puts(seq, "addr  callsign  dev  qual lock count failed digipeaters\n");
926 	else {
927 		struct nr_neigh *nr_neigh;
928 
929 		nr_neigh = hlist_entry(v, struct nr_neigh, neigh_node);
930 		seq_printf(seq, "%05d %-9s %-4s  %3d    %d   %3d    %3d",
931 			nr_neigh->number,
932 			ax2asc(buf, &nr_neigh->callsign),
933 			nr_neigh->dev ? nr_neigh->dev->name : "???",
934 			nr_neigh->quality,
935 			nr_neigh->locked,
936 			nr_neigh->count,
937 			nr_neigh->failed);
938 
939 		if (nr_neigh->digipeat != NULL) {
940 			for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
941 				seq_printf(seq, " %s",
942 					   ax2asc(buf, &nr_neigh->digipeat->calls[i]));
943 		}
944 
945 		seq_puts(seq, "\n");
946 	}
947 	return 0;
948 }
949 
950 const struct seq_operations nr_neigh_seqops = {
951 	.start = nr_neigh_start,
952 	.next = nr_neigh_next,
953 	.stop = nr_neigh_stop,
954 	.show = nr_neigh_show,
955 };
956 #endif
957 
958 /*
959  *	Free all memory associated with the nodes and routes lists.
960  */
961 void nr_rt_free(void)
962 {
963 	struct nr_neigh *s = NULL;
964 	struct nr_node  *t = NULL;
965 	struct hlist_node *nodet;
966 
967 	spin_lock_bh(&nr_neigh_list_lock);
968 	spin_lock_bh(&nr_node_list_lock);
969 	nr_node_for_each_safe(t, nodet, &nr_node_list) {
970 		nr_node_lock(t);
971 		nr_remove_node_locked(t);
972 		nr_node_unlock(t);
973 	}
974 	nr_neigh_for_each_safe(s, nodet, &nr_neigh_list) {
975 		while(s->count) {
976 			s->count--;
977 			nr_neigh_put(s);
978 		}
979 		nr_remove_neigh_locked(s);
980 	}
981 	spin_unlock_bh(&nr_node_list_lock);
982 	spin_unlock_bh(&nr_neigh_list_lock);
983 }
984