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