Loading...
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 = 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 strscpy(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 strscpy(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
288static 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
296static 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
305static 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 */
316static 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 */
379static 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 */
427static 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 */
450static 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 */
507void 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 */
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 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 */
589struct 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;
602out:
603 rcu_read_unlock();
604 return dev;
605}
606
607static 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 */
629int 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 */
705void 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 */
746int 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 * Reject malformed packets early. Check that it contains at least 2
759 * addresses and 1 byte more for Time-To-Live
760 */
761 if (skb->len < 2 * sizeof(ax25_address) + 1)
762 return 0;
763
764 nr_src = (ax25_address *)(skb->data + 0);
765 nr_dest = (ax25_address *)(skb->data + 7);
766
767 if (ax25 != NULL) {
768 ret = nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
769 ax25->ax25_dev->dev, 0,
770 READ_ONCE(sysctl_netrom_obsolescence_count_initialiser));
771 if (ret)
772 return ret;
773 }
774
775 if ((dev = nr_dev_get(nr_dest)) != NULL) { /* Its for me */
776 if (ax25 == NULL) /* Its from me */
777 ret = nr_loopback_queue(skb);
778 else
779 ret = nr_rx_frame(skb, dev);
780 dev_put(dev);
781 return ret;
782 }
783
784 if (!READ_ONCE(sysctl_netrom_routing_control) && ax25 != NULL)
785 return 0;
786
787 /* Its Time-To-Live has expired */
788 if (skb->data[14] == 1) {
789 return 0;
790 }
791
792 nr_node = nr_node_get(nr_dest);
793 if (nr_node == NULL)
794 return 0;
795 nr_node_lock(nr_node);
796
797 if (nr_node->which >= nr_node->count) {
798 nr_node_unlock(nr_node);
799 nr_node_put(nr_node);
800 return 0;
801 }
802
803 nr_neigh = nr_node->routes[nr_node->which].neighbour;
804
805 if ((dev = nr_dev_first()) == NULL) {
806 nr_node_unlock(nr_node);
807 nr_node_put(nr_node);
808 return 0;
809 }
810
811 /* We are going to change the netrom headers so we should get our
812 own skb, we also did not know until now how much header space
813 we had to reserve... - RXQ */
814 if ((skbn=skb_copy_expand(skb, dev->hard_header_len, 0, GFP_ATOMIC)) == NULL) {
815 nr_node_unlock(nr_node);
816 nr_node_put(nr_node);
817 dev_put(dev);
818 return 0;
819 }
820 kfree_skb(skb);
821 skb=skbn;
822 skb->data[14]--;
823
824 dptr = skb_push(skb, 1);
825 *dptr = AX25_P_NETROM;
826
827 ax25s = nr_neigh->ax25;
828 nr_neigh->ax25 = ax25_send_frame(skb, 256,
829 (const ax25_address *)dev->dev_addr,
830 &nr_neigh->callsign,
831 nr_neigh->digipeat, nr_neigh->dev);
832 if (ax25s)
833 ax25_cb_put(ax25s);
834
835 dev_put(dev);
836 ret = (nr_neigh->ax25 != NULL);
837 nr_node_unlock(nr_node);
838 nr_node_put(nr_node);
839
840 return ret;
841}
842
843#ifdef CONFIG_PROC_FS
844
845static void *nr_node_start(struct seq_file *seq, loff_t *pos)
846 __acquires(&nr_node_list_lock)
847{
848 spin_lock_bh(&nr_node_list_lock);
849 return seq_hlist_start_head(&nr_node_list, *pos);
850}
851
852static void *nr_node_next(struct seq_file *seq, void *v, loff_t *pos)
853{
854 return seq_hlist_next(v, &nr_node_list, pos);
855}
856
857static void nr_node_stop(struct seq_file *seq, void *v)
858 __releases(&nr_node_list_lock)
859{
860 spin_unlock_bh(&nr_node_list_lock);
861}
862
863static int nr_node_show(struct seq_file *seq, void *v)
864{
865 char buf[11];
866 int i;
867
868 if (v == SEQ_START_TOKEN)
869 seq_puts(seq,
870 "callsign mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
871 else {
872 struct nr_node *nr_node = hlist_entry(v, struct nr_node,
873 node_node);
874
875 nr_node_lock(nr_node);
876 seq_printf(seq, "%-9s %-7s %d %d",
877 ax2asc(buf, &nr_node->callsign),
878 (nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
879 nr_node->which + 1,
880 nr_node->count);
881
882 for (i = 0; i < nr_node->count; i++) {
883 seq_printf(seq, " %3d %d %05d",
884 nr_node->routes[i].quality,
885 nr_node->routes[i].obs_count,
886 nr_node->routes[i].neighbour->number);
887 }
888 nr_node_unlock(nr_node);
889
890 seq_puts(seq, "\n");
891 }
892 return 0;
893}
894
895const struct seq_operations nr_node_seqops = {
896 .start = nr_node_start,
897 .next = nr_node_next,
898 .stop = nr_node_stop,
899 .show = nr_node_show,
900};
901
902static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
903 __acquires(&nr_neigh_list_lock)
904{
905 spin_lock_bh(&nr_neigh_list_lock);
906 return seq_hlist_start_head(&nr_neigh_list, *pos);
907}
908
909static void *nr_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
910{
911 return seq_hlist_next(v, &nr_neigh_list, pos);
912}
913
914static void nr_neigh_stop(struct seq_file *seq, void *v)
915 __releases(&nr_neigh_list_lock)
916{
917 spin_unlock_bh(&nr_neigh_list_lock);
918}
919
920static int nr_neigh_show(struct seq_file *seq, void *v)
921{
922 char buf[11];
923 int i;
924
925 if (v == SEQ_START_TOKEN)
926 seq_puts(seq, "addr callsign dev qual lock count failed digipeaters\n");
927 else {
928 struct nr_neigh *nr_neigh;
929
930 nr_neigh = hlist_entry(v, struct nr_neigh, neigh_node);
931 seq_printf(seq, "%05d %-9s %-4s %3d %d %3d %3d",
932 nr_neigh->number,
933 ax2asc(buf, &nr_neigh->callsign),
934 nr_neigh->dev ? nr_neigh->dev->name : "???",
935 nr_neigh->quality,
936 nr_neigh->locked,
937 nr_neigh->count,
938 nr_neigh->failed);
939
940 if (nr_neigh->digipeat != NULL) {
941 for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
942 seq_printf(seq, " %s",
943 ax2asc(buf, &nr_neigh->digipeat->calls[i]));
944 }
945
946 seq_puts(seq, "\n");
947 }
948 return 0;
949}
950
951const struct seq_operations nr_neigh_seqops = {
952 .start = nr_neigh_start,
953 .next = nr_neigh_next,
954 .stop = nr_neigh_stop,
955 .show = nr_neigh_show,
956};
957#endif
958
959/*
960 * Free all memory associated with the nodes and routes lists.
961 */
962void nr_rt_free(void)
963{
964 struct nr_neigh *s = NULL;
965 struct nr_node *t = NULL;
966 struct hlist_node *nodet;
967
968 spin_lock_bh(&nr_neigh_list_lock);
969 spin_lock_bh(&nr_node_list_lock);
970 nr_node_for_each_safe(t, nodet, &nr_node_list) {
971 nr_node_lock(t);
972 nr_remove_node_locked(t);
973 nr_node_unlock(t);
974 }
975 nr_neigh_for_each_safe(s, nodet, &nr_neigh_list) {
976 while(s->count) {
977 s->count--;
978 nr_neigh_put(s);
979 }
980 nr_remove_neigh_locked(s);
981 }
982 spin_unlock_bh(&nr_node_list_lock);
983 spin_unlock_bh(&nr_neigh_list_lock);
984}
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/* re-sort the routes in quality order. */
84static void re_sort_routes(struct nr_node *nr_node, int x, int y)
85{
86 if (nr_node->routes[y].quality > nr_node->routes[x].quality) {
87 if (nr_node->which == x)
88 nr_node->which = y;
89 else if (nr_node->which == y)
90 nr_node->which = x;
91
92 swap(nr_node->routes[x], nr_node->routes[y]);
93 }
94}
95
96/*
97 * Add a new route to a node, and in the process add the node and the
98 * neighbour if it is new.
99 */
100static int __must_check nr_add_node(ax25_address *nr, const char *mnemonic,
101 ax25_address *ax25, ax25_digi *ax25_digi, struct net_device *dev,
102 int quality, int obs_count)
103{
104 struct nr_node *nr_node;
105 struct nr_neigh *nr_neigh;
106 int i, found;
107 struct net_device *odev;
108
109 if ((odev=nr_dev_get(nr)) != NULL) { /* Can't add routes to ourself */
110 dev_put(odev);
111 return -EINVAL;
112 }
113
114 nr_node = nr_node_get(nr);
115
116 nr_neigh = nr_neigh_get_dev(ax25, dev);
117
118 /*
119 * The L2 link to a neighbour has failed in the past
120 * and now a frame comes from this neighbour. We assume
121 * it was a temporary trouble with the link and reset the
122 * routes now (and not wait for a node broadcast).
123 */
124 if (nr_neigh != NULL && nr_neigh->failed != 0 && quality == 0) {
125 struct nr_node *nr_nodet;
126
127 spin_lock_bh(&nr_node_list_lock);
128 nr_node_for_each(nr_nodet, &nr_node_list) {
129 nr_node_lock(nr_nodet);
130 for (i = 0; i < nr_nodet->count; i++)
131 if (nr_nodet->routes[i].neighbour == nr_neigh)
132 if (i < nr_nodet->which)
133 nr_nodet->which = i;
134 nr_node_unlock(nr_nodet);
135 }
136 spin_unlock_bh(&nr_node_list_lock);
137 }
138
139 if (nr_neigh != NULL)
140 nr_neigh->failed = 0;
141
142 if (quality == 0 && nr_neigh != NULL && nr_node != NULL) {
143 nr_neigh_put(nr_neigh);
144 nr_node_put(nr_node);
145 return 0;
146 }
147
148 if (nr_neigh == NULL) {
149 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL) {
150 if (nr_node)
151 nr_node_put(nr_node);
152 return -ENOMEM;
153 }
154
155 nr_neigh->callsign = *ax25;
156 nr_neigh->digipeat = NULL;
157 nr_neigh->ax25 = NULL;
158 nr_neigh->dev = dev;
159 nr_neigh->quality = sysctl_netrom_default_path_quality;
160 nr_neigh->locked = 0;
161 nr_neigh->count = 0;
162 nr_neigh->number = nr_neigh_no++;
163 nr_neigh->failed = 0;
164 refcount_set(&nr_neigh->refcount, 1);
165
166 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
167 nr_neigh->digipeat = kmemdup(ax25_digi,
168 sizeof(*ax25_digi),
169 GFP_KERNEL);
170 if (nr_neigh->digipeat == NULL) {
171 kfree(nr_neigh);
172 if (nr_node)
173 nr_node_put(nr_node);
174 return -ENOMEM;
175 }
176 }
177
178 spin_lock_bh(&nr_neigh_list_lock);
179 hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
180 nr_neigh_hold(nr_neigh);
181 spin_unlock_bh(&nr_neigh_list_lock);
182 }
183
184 if (quality != 0 && ax25cmp(nr, ax25) == 0 && !nr_neigh->locked)
185 nr_neigh->quality = quality;
186
187 if (nr_node == NULL) {
188 if ((nr_node = kmalloc(sizeof(*nr_node), GFP_ATOMIC)) == NULL) {
189 if (nr_neigh)
190 nr_neigh_put(nr_neigh);
191 return -ENOMEM;
192 }
193
194 nr_node->callsign = *nr;
195 strcpy(nr_node->mnemonic, mnemonic);
196
197 nr_node->which = 0;
198 nr_node->count = 1;
199 refcount_set(&nr_node->refcount, 1);
200 spin_lock_init(&nr_node->node_lock);
201
202 nr_node->routes[0].quality = quality;
203 nr_node->routes[0].obs_count = obs_count;
204 nr_node->routes[0].neighbour = nr_neigh;
205
206 nr_neigh_hold(nr_neigh);
207 nr_neigh->count++;
208
209 spin_lock_bh(&nr_node_list_lock);
210 hlist_add_head(&nr_node->node_node, &nr_node_list);
211 /* refcount initialized at 1 */
212 spin_unlock_bh(&nr_node_list_lock);
213
214 return 0;
215 }
216 nr_node_lock(nr_node);
217
218 if (quality != 0)
219 strcpy(nr_node->mnemonic, mnemonic);
220
221 for (found = 0, i = 0; i < nr_node->count; i++) {
222 if (nr_node->routes[i].neighbour == nr_neigh) {
223 nr_node->routes[i].quality = quality;
224 nr_node->routes[i].obs_count = obs_count;
225 found = 1;
226 break;
227 }
228 }
229
230 if (!found) {
231 /* We have space at the bottom, slot it in */
232 if (nr_node->count < 3) {
233 nr_node->routes[2] = nr_node->routes[1];
234 nr_node->routes[1] = nr_node->routes[0];
235
236 nr_node->routes[0].quality = quality;
237 nr_node->routes[0].obs_count = obs_count;
238 nr_node->routes[0].neighbour = nr_neigh;
239
240 nr_node->which++;
241 nr_node->count++;
242 nr_neigh_hold(nr_neigh);
243 nr_neigh->count++;
244 } else {
245 /* It must be better than the worst */
246 if (quality > nr_node->routes[2].quality) {
247 nr_node->routes[2].neighbour->count--;
248 nr_neigh_put(nr_node->routes[2].neighbour);
249
250 if (nr_node->routes[2].neighbour->count == 0 && !nr_node->routes[2].neighbour->locked)
251 nr_remove_neigh(nr_node->routes[2].neighbour);
252
253 nr_node->routes[2].quality = quality;
254 nr_node->routes[2].obs_count = obs_count;
255 nr_node->routes[2].neighbour = nr_neigh;
256
257 nr_neigh_hold(nr_neigh);
258 nr_neigh->count++;
259 }
260 }
261 }
262
263 /* Now re-sort the routes in quality order */
264 switch (nr_node->count) {
265 case 3:
266 re_sort_routes(nr_node, 0, 1);
267 re_sort_routes(nr_node, 1, 2);
268 /* fall through */
269 case 2:
270 re_sort_routes(nr_node, 0, 1);
271 case 1:
272 break;
273 }
274
275 for (i = 0; i < nr_node->count; i++) {
276 if (nr_node->routes[i].neighbour == nr_neigh) {
277 if (i < nr_node->which)
278 nr_node->which = i;
279 break;
280 }
281 }
282
283 nr_neigh_put(nr_neigh);
284 nr_node_unlock(nr_node);
285 nr_node_put(nr_node);
286 return 0;
287}
288
289static inline void __nr_remove_node(struct nr_node *nr_node)
290{
291 hlist_del_init(&nr_node->node_node);
292 nr_node_put(nr_node);
293}
294
295#define nr_remove_node_locked(__node) \
296 __nr_remove_node(__node)
297
298static void nr_remove_node(struct nr_node *nr_node)
299{
300 spin_lock_bh(&nr_node_list_lock);
301 __nr_remove_node(nr_node);
302 spin_unlock_bh(&nr_node_list_lock);
303}
304
305static inline void __nr_remove_neigh(struct nr_neigh *nr_neigh)
306{
307 hlist_del_init(&nr_neigh->neigh_node);
308 nr_neigh_put(nr_neigh);
309}
310
311#define nr_remove_neigh_locked(__neigh) \
312 __nr_remove_neigh(__neigh)
313
314static void nr_remove_neigh(struct nr_neigh *nr_neigh)
315{
316 spin_lock_bh(&nr_neigh_list_lock);
317 __nr_remove_neigh(nr_neigh);
318 spin_unlock_bh(&nr_neigh_list_lock);
319}
320
321/*
322 * "Delete" a node. Strictly speaking remove a route to a node. The node
323 * is only deleted if no routes are left to it.
324 */
325static int nr_del_node(ax25_address *callsign, ax25_address *neighbour, struct net_device *dev)
326{
327 struct nr_node *nr_node;
328 struct nr_neigh *nr_neigh;
329 int i;
330
331 nr_node = nr_node_get(callsign);
332
333 if (nr_node == NULL)
334 return -EINVAL;
335
336 nr_neigh = nr_neigh_get_dev(neighbour, dev);
337
338 if (nr_neigh == NULL) {
339 nr_node_put(nr_node);
340 return -EINVAL;
341 }
342
343 nr_node_lock(nr_node);
344 for (i = 0; i < nr_node->count; i++) {
345 if (nr_node->routes[i].neighbour == nr_neigh) {
346 nr_neigh->count--;
347 nr_neigh_put(nr_neigh);
348
349 if (nr_neigh->count == 0 && !nr_neigh->locked)
350 nr_remove_neigh(nr_neigh);
351 nr_neigh_put(nr_neigh);
352
353 nr_node->count--;
354
355 if (nr_node->count == 0) {
356 nr_remove_node(nr_node);
357 } else {
358 switch (i) {
359 case 0:
360 nr_node->routes[0] = nr_node->routes[1];
361 /* fall through */
362 case 1:
363 nr_node->routes[1] = nr_node->routes[2];
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 */
384static 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 */
432static 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 */
455static 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 case 2:
488 break;
489 }
490 break;
491
492 default:
493 s->routes[i].obs_count--;
494 break;
495
496 }
497 }
498
499 if (s->count <= 0)
500 nr_remove_node_locked(s);
501 nr_node_unlock(s);
502 }
503 spin_unlock_bh(&nr_node_list_lock);
504
505 return 0;
506}
507
508/*
509 * A device has been removed. Remove its routes and neighbours.
510 */
511void nr_rt_device_down(struct net_device *dev)
512{
513 struct nr_neigh *s;
514 struct hlist_node *nodet, *node2t;
515 struct nr_node *t;
516 int i;
517
518 spin_lock_bh(&nr_neigh_list_lock);
519 nr_neigh_for_each_safe(s, nodet, &nr_neigh_list) {
520 if (s->dev == dev) {
521 spin_lock_bh(&nr_node_list_lock);
522 nr_node_for_each_safe(t, node2t, &nr_node_list) {
523 nr_node_lock(t);
524 for (i = 0; i < t->count; i++) {
525 if (t->routes[i].neighbour == s) {
526 t->count--;
527
528 switch (i) {
529 case 0:
530 t->routes[0] = t->routes[1];
531 /* fall through */
532 case 1:
533 t->routes[1] = t->routes[2];
534 case 2:
535 break;
536 }
537 }
538 }
539
540 if (t->count <= 0)
541 nr_remove_node_locked(t);
542 nr_node_unlock(t);
543 }
544 spin_unlock_bh(&nr_node_list_lock);
545
546 nr_remove_neigh_locked(s);
547 }
548 }
549 spin_unlock_bh(&nr_neigh_list_lock);
550}
551
552/*
553 * Check that the device given is a valid AX.25 interface that is "up".
554 * Or a valid ethernet interface with an AX.25 callsign binding.
555 */
556static struct net_device *nr_ax25_dev_get(char *devname)
557{
558 struct net_device *dev;
559
560 if ((dev = dev_get_by_name(&init_net, devname)) == NULL)
561 return NULL;
562
563 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
564 return dev;
565
566 dev_put(dev);
567 return NULL;
568}
569
570/*
571 * Find the first active NET/ROM device, usually "nr0".
572 */
573struct net_device *nr_dev_first(void)
574{
575 struct net_device *dev, *first = NULL;
576
577 rcu_read_lock();
578 for_each_netdev_rcu(&init_net, dev) {
579 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM)
580 if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
581 first = dev;
582 }
583 if (first)
584 dev_hold(first);
585 rcu_read_unlock();
586
587 return first;
588}
589
590/*
591 * Find the NET/ROM device for the given callsign.
592 */
593struct net_device *nr_dev_get(ax25_address *addr)
594{
595 struct net_device *dev;
596
597 rcu_read_lock();
598 for_each_netdev_rcu(&init_net, dev) {
599 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM &&
600 ax25cmp(addr, (ax25_address *)dev->dev_addr) == 0) {
601 dev_hold(dev);
602 goto out;
603 }
604 }
605 dev = NULL;
606out:
607 rcu_read_unlock();
608 return dev;
609}
610
611static ax25_digi *nr_call_to_digi(ax25_digi *digi, int ndigis,
612 ax25_address *digipeaters)
613{
614 int i;
615
616 if (ndigis == 0)
617 return NULL;
618
619 for (i = 0; i < ndigis; i++) {
620 digi->calls[i] = digipeaters[i];
621 digi->repeated[i] = 0;
622 }
623
624 digi->ndigi = ndigis;
625 digi->lastrepeat = -1;
626
627 return digi;
628}
629
630/*
631 * Handle the ioctls that control the routing functions.
632 */
633int nr_rt_ioctl(unsigned int cmd, void __user *arg)
634{
635 struct nr_route_struct nr_route;
636 struct net_device *dev;
637 ax25_digi digi;
638 int ret;
639
640 switch (cmd) {
641 case SIOCADDRT:
642 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
643 return -EFAULT;
644 if (nr_route.ndigis > AX25_MAX_DIGIS)
645 return -EINVAL;
646 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
647 return -EINVAL;
648 switch (nr_route.type) {
649 case NETROM_NODE:
650 if (strnlen(nr_route.mnemonic, 7) == 7) {
651 ret = -EINVAL;
652 break;
653 }
654
655 ret = nr_add_node(&nr_route.callsign,
656 nr_route.mnemonic,
657 &nr_route.neighbour,
658 nr_call_to_digi(&digi, nr_route.ndigis,
659 nr_route.digipeaters),
660 dev, nr_route.quality,
661 nr_route.obs_count);
662 break;
663 case NETROM_NEIGH:
664 ret = nr_add_neigh(&nr_route.callsign,
665 nr_call_to_digi(&digi, nr_route.ndigis,
666 nr_route.digipeaters),
667 dev, nr_route.quality);
668 break;
669 default:
670 ret = -EINVAL;
671 }
672 dev_put(dev);
673 return ret;
674
675 case SIOCDELRT:
676 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
677 return -EFAULT;
678 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
679 return -EINVAL;
680 switch (nr_route.type) {
681 case NETROM_NODE:
682 ret = nr_del_node(&nr_route.callsign,
683 &nr_route.neighbour, dev);
684 break;
685 case NETROM_NEIGH:
686 ret = nr_del_neigh(&nr_route.callsign,
687 dev, nr_route.quality);
688 break;
689 default:
690 ret = -EINVAL;
691 }
692 dev_put(dev);
693 return ret;
694
695 case SIOCNRDECOBS:
696 return nr_dec_obs();
697
698 default:
699 return -EINVAL;
700 }
701
702 return 0;
703}
704
705/*
706 * A level 2 link has timed out, therefore it appears to be a poor link,
707 * then don't use that neighbour until it is reset.
708 */
709void nr_link_failed(ax25_cb *ax25, int reason)
710{
711 struct nr_neigh *s, *nr_neigh = NULL;
712 struct nr_node *nr_node = NULL;
713
714 spin_lock_bh(&nr_neigh_list_lock);
715 nr_neigh_for_each(s, &nr_neigh_list) {
716 if (s->ax25 == ax25) {
717 nr_neigh_hold(s);
718 nr_neigh = s;
719 break;
720 }
721 }
722 spin_unlock_bh(&nr_neigh_list_lock);
723
724 if (nr_neigh == NULL)
725 return;
726
727 nr_neigh->ax25 = NULL;
728 ax25_cb_put(ax25);
729
730 if (++nr_neigh->failed < sysctl_netrom_link_fails_count) {
731 nr_neigh_put(nr_neigh);
732 return;
733 }
734 spin_lock_bh(&nr_node_list_lock);
735 nr_node_for_each(nr_node, &nr_node_list) {
736 nr_node_lock(nr_node);
737 if (nr_node->which < nr_node->count &&
738 nr_node->routes[nr_node->which].neighbour == nr_neigh)
739 nr_node->which++;
740 nr_node_unlock(nr_node);
741 }
742 spin_unlock_bh(&nr_node_list_lock);
743 nr_neigh_put(nr_neigh);
744}
745
746/*
747 * Route a frame to an appropriate AX.25 connection. A NULL ax25_cb
748 * indicates an internally generated frame.
749 */
750int nr_route_frame(struct sk_buff *skb, ax25_cb *ax25)
751{
752 ax25_address *nr_src, *nr_dest;
753 struct nr_neigh *nr_neigh;
754 struct nr_node *nr_node;
755 struct net_device *dev;
756 unsigned char *dptr;
757 ax25_cb *ax25s;
758 int ret;
759 struct sk_buff *skbn;
760
761
762 nr_src = (ax25_address *)(skb->data + 0);
763 nr_dest = (ax25_address *)(skb->data + 7);
764
765 if (ax25 != NULL) {
766 ret = nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
767 ax25->ax25_dev->dev, 0,
768 sysctl_netrom_obsolescence_count_initialiser);
769 if (ret)
770 return ret;
771 }
772
773 if ((dev = nr_dev_get(nr_dest)) != NULL) { /* Its for me */
774 if (ax25 == NULL) /* Its from me */
775 ret = nr_loopback_queue(skb);
776 else
777 ret = nr_rx_frame(skb, dev);
778 dev_put(dev);
779 return ret;
780 }
781
782 if (!sysctl_netrom_routing_control && ax25 != NULL)
783 return 0;
784
785 /* Its Time-To-Live has expired */
786 if (skb->data[14] == 1) {
787 return 0;
788 }
789
790 nr_node = nr_node_get(nr_dest);
791 if (nr_node == NULL)
792 return 0;
793 nr_node_lock(nr_node);
794
795 if (nr_node->which >= nr_node->count) {
796 nr_node_unlock(nr_node);
797 nr_node_put(nr_node);
798 return 0;
799 }
800
801 nr_neigh = nr_node->routes[nr_node->which].neighbour;
802
803 if ((dev = nr_dev_first()) == NULL) {
804 nr_node_unlock(nr_node);
805 nr_node_put(nr_node);
806 return 0;
807 }
808
809 /* We are going to change the netrom headers so we should get our
810 own skb, we also did not know until now how much header space
811 we had to reserve... - RXQ */
812 if ((skbn=skb_copy_expand(skb, dev->hard_header_len, 0, GFP_ATOMIC)) == NULL) {
813 nr_node_unlock(nr_node);
814 nr_node_put(nr_node);
815 dev_put(dev);
816 return 0;
817 }
818 kfree_skb(skb);
819 skb=skbn;
820 skb->data[14]--;
821
822 dptr = skb_push(skb, 1);
823 *dptr = AX25_P_NETROM;
824
825 ax25s = nr_neigh->ax25;
826 nr_neigh->ax25 = ax25_send_frame(skb, 256,
827 (ax25_address *)dev->dev_addr,
828 &nr_neigh->callsign,
829 nr_neigh->digipeat, nr_neigh->dev);
830 if (ax25s)
831 ax25_cb_put(ax25s);
832
833 dev_put(dev);
834 ret = (nr_neigh->ax25 != NULL);
835 nr_node_unlock(nr_node);
836 nr_node_put(nr_node);
837
838 return ret;
839}
840
841#ifdef CONFIG_PROC_FS
842
843static void *nr_node_start(struct seq_file *seq, loff_t *pos)
844{
845 spin_lock_bh(&nr_node_list_lock);
846 return seq_hlist_start_head(&nr_node_list, *pos);
847}
848
849static void *nr_node_next(struct seq_file *seq, void *v, loff_t *pos)
850{
851 return seq_hlist_next(v, &nr_node_list, pos);
852}
853
854static void nr_node_stop(struct seq_file *seq, void *v)
855{
856 spin_unlock_bh(&nr_node_list_lock);
857}
858
859static int nr_node_show(struct seq_file *seq, void *v)
860{
861 char buf[11];
862 int i;
863
864 if (v == SEQ_START_TOKEN)
865 seq_puts(seq,
866 "callsign mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
867 else {
868 struct nr_node *nr_node = hlist_entry(v, struct nr_node,
869 node_node);
870
871 nr_node_lock(nr_node);
872 seq_printf(seq, "%-9s %-7s %d %d",
873 ax2asc(buf, &nr_node->callsign),
874 (nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
875 nr_node->which + 1,
876 nr_node->count);
877
878 for (i = 0; i < nr_node->count; i++) {
879 seq_printf(seq, " %3d %d %05d",
880 nr_node->routes[i].quality,
881 nr_node->routes[i].obs_count,
882 nr_node->routes[i].neighbour->number);
883 }
884 nr_node_unlock(nr_node);
885
886 seq_puts(seq, "\n");
887 }
888 return 0;
889}
890
891static const struct seq_operations nr_node_seqops = {
892 .start = nr_node_start,
893 .next = nr_node_next,
894 .stop = nr_node_stop,
895 .show = nr_node_show,
896};
897
898static int nr_node_info_open(struct inode *inode, struct file *file)
899{
900 return seq_open(file, &nr_node_seqops);
901}
902
903const struct file_operations nr_nodes_fops = {
904 .open = nr_node_info_open,
905 .read = seq_read,
906 .llseek = seq_lseek,
907 .release = seq_release,
908};
909
910static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
911{
912 spin_lock_bh(&nr_neigh_list_lock);
913 return seq_hlist_start_head(&nr_neigh_list, *pos);
914}
915
916static void *nr_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
917{
918 return seq_hlist_next(v, &nr_neigh_list, pos);
919}
920
921static void nr_neigh_stop(struct seq_file *seq, void *v)
922{
923 spin_unlock_bh(&nr_neigh_list_lock);
924}
925
926static int nr_neigh_show(struct seq_file *seq, void *v)
927{
928 char buf[11];
929 int i;
930
931 if (v == SEQ_START_TOKEN)
932 seq_puts(seq, "addr callsign dev qual lock count failed digipeaters\n");
933 else {
934 struct nr_neigh *nr_neigh;
935
936 nr_neigh = hlist_entry(v, struct nr_neigh, neigh_node);
937 seq_printf(seq, "%05d %-9s %-4s %3d %d %3d %3d",
938 nr_neigh->number,
939 ax2asc(buf, &nr_neigh->callsign),
940 nr_neigh->dev ? nr_neigh->dev->name : "???",
941 nr_neigh->quality,
942 nr_neigh->locked,
943 nr_neigh->count,
944 nr_neigh->failed);
945
946 if (nr_neigh->digipeat != NULL) {
947 for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
948 seq_printf(seq, " %s",
949 ax2asc(buf, &nr_neigh->digipeat->calls[i]));
950 }
951
952 seq_puts(seq, "\n");
953 }
954 return 0;
955}
956
957static const struct seq_operations nr_neigh_seqops = {
958 .start = nr_neigh_start,
959 .next = nr_neigh_next,
960 .stop = nr_neigh_stop,
961 .show = nr_neigh_show,
962};
963
964static int nr_neigh_info_open(struct inode *inode, struct file *file)
965{
966 return seq_open(file, &nr_neigh_seqops);
967}
968
969const struct file_operations nr_neigh_fops = {
970 .open = nr_neigh_info_open,
971 .read = seq_read,
972 .llseek = seq_lseek,
973 .release = seq_release,
974};
975
976#endif
977
978/*
979 * Free all memory associated with the nodes and routes lists.
980 */
981void __exit nr_rt_free(void)
982{
983 struct nr_neigh *s = NULL;
984 struct nr_node *t = NULL;
985 struct hlist_node *nodet;
986
987 spin_lock_bh(&nr_neigh_list_lock);
988 spin_lock_bh(&nr_node_list_lock);
989 nr_node_for_each_safe(t, nodet, &nr_node_list) {
990 nr_node_lock(t);
991 nr_remove_node_locked(t);
992 nr_node_unlock(t);
993 }
994 nr_neigh_for_each_safe(s, nodet, &nr_neigh_list) {
995 while(s->count) {
996 s->count--;
997 nr_neigh_put(s);
998 }
999 nr_remove_neigh_locked(s);
1000 }
1001 spin_unlock_bh(&nr_node_list_lock);
1002 spin_unlock_bh(&nr_neigh_list_lock);
1003}