spi-topcliff-pch: supports a spi mode setup and bit order setup by IO control
[zen-stable.git] / net / netrom / nr_route.c
blob2cf330162d7e8e21ddcbc21eb741336e332ec422
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.
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)
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 <asm/uaccess.h>
29 #include <asm/system.h>
30 #include <linux/fcntl.h>
31 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
32 #include <linux/mm.h>
33 #include <linux/interrupt.h>
34 #include <linux/notifier.h>
35 #include <linux/netfilter.h>
36 #include <linux/init.h>
37 #include <linux/spinlock.h>
38 #include <net/netrom.h>
39 #include <linux/seq_file.h>
40 #include <linux/export.h>
42 static unsigned int nr_neigh_no = 1;
44 static HLIST_HEAD(nr_node_list);
45 static DEFINE_SPINLOCK(nr_node_list_lock);
46 static HLIST_HEAD(nr_neigh_list);
47 static DEFINE_SPINLOCK(nr_neigh_list_lock);
49 static struct nr_node *nr_node_get(ax25_address *callsign)
51 struct nr_node *found = NULL;
52 struct nr_node *nr_node;
53 struct hlist_node *node;
55 spin_lock_bh(&nr_node_list_lock);
56 nr_node_for_each(nr_node, node, &nr_node_list)
57 if (ax25cmp(callsign, &nr_node->callsign) == 0) {
58 nr_node_hold(nr_node);
59 found = nr_node;
60 break;
62 spin_unlock_bh(&nr_node_list_lock);
63 return found;
66 static struct nr_neigh *nr_neigh_get_dev(ax25_address *callsign,
67 struct net_device *dev)
69 struct nr_neigh *found = NULL;
70 struct nr_neigh *nr_neigh;
71 struct hlist_node *node;
73 spin_lock_bh(&nr_neigh_list_lock);
74 nr_neigh_for_each(nr_neigh, node, &nr_neigh_list)
75 if (ax25cmp(callsign, &nr_neigh->callsign) == 0 &&
76 nr_neigh->dev == dev) {
77 nr_neigh_hold(nr_neigh);
78 found = nr_neigh;
79 break;
81 spin_unlock_bh(&nr_neigh_list_lock);
82 return found;
85 static void nr_remove_neigh(struct nr_neigh *);
88 * Add a new route to a node, and in the process add the node and the
89 * neighbour if it is new.
91 static int __must_check nr_add_node(ax25_address *nr, const char *mnemonic,
92 ax25_address *ax25, ax25_digi *ax25_digi, struct net_device *dev,
93 int quality, int obs_count)
95 struct nr_node *nr_node;
96 struct nr_neigh *nr_neigh;
97 struct nr_route nr_route;
98 int i, found;
99 struct net_device *odev;
101 if ((odev=nr_dev_get(nr)) != NULL) { /* Can't add routes to ourself */
102 dev_put(odev);
103 return -EINVAL;
106 nr_node = nr_node_get(nr);
108 nr_neigh = nr_neigh_get_dev(ax25, dev);
111 * The L2 link to a neighbour has failed in the past
112 * and now a frame comes from this neighbour. We assume
113 * it was a temporary trouble with the link and reset the
114 * routes now (and not wait for a node broadcast).
116 if (nr_neigh != NULL && nr_neigh->failed != 0 && quality == 0) {
117 struct nr_node *nr_nodet;
118 struct hlist_node *node;
120 spin_lock_bh(&nr_node_list_lock);
121 nr_node_for_each(nr_nodet, node, &nr_node_list) {
122 nr_node_lock(nr_nodet);
123 for (i = 0; i < nr_nodet->count; i++)
124 if (nr_nodet->routes[i].neighbour == nr_neigh)
125 if (i < nr_nodet->which)
126 nr_nodet->which = i;
127 nr_node_unlock(nr_nodet);
129 spin_unlock_bh(&nr_node_list_lock);
132 if (nr_neigh != NULL)
133 nr_neigh->failed = 0;
135 if (quality == 0 && nr_neigh != NULL && nr_node != NULL) {
136 nr_neigh_put(nr_neigh);
137 nr_node_put(nr_node);
138 return 0;
141 if (nr_neigh == NULL) {
142 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL) {
143 if (nr_node)
144 nr_node_put(nr_node);
145 return -ENOMEM;
148 nr_neigh->callsign = *ax25;
149 nr_neigh->digipeat = NULL;
150 nr_neigh->ax25 = NULL;
151 nr_neigh->dev = dev;
152 nr_neigh->quality = sysctl_netrom_default_path_quality;
153 nr_neigh->locked = 0;
154 nr_neigh->count = 0;
155 nr_neigh->number = nr_neigh_no++;
156 nr_neigh->failed = 0;
157 atomic_set(&nr_neigh->refcount, 1);
159 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
160 nr_neigh->digipeat = kmemdup(ax25_digi,
161 sizeof(*ax25_digi),
162 GFP_KERNEL);
163 if (nr_neigh->digipeat == NULL) {
164 kfree(nr_neigh);
165 if (nr_node)
166 nr_node_put(nr_node);
167 return -ENOMEM;
171 spin_lock_bh(&nr_neigh_list_lock);
172 hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
173 nr_neigh_hold(nr_neigh);
174 spin_unlock_bh(&nr_neigh_list_lock);
177 if (quality != 0 && ax25cmp(nr, ax25) == 0 && !nr_neigh->locked)
178 nr_neigh->quality = quality;
180 if (nr_node == NULL) {
181 if ((nr_node = kmalloc(sizeof(*nr_node), GFP_ATOMIC)) == NULL) {
182 if (nr_neigh)
183 nr_neigh_put(nr_neigh);
184 return -ENOMEM;
187 nr_node->callsign = *nr;
188 strcpy(nr_node->mnemonic, mnemonic);
190 nr_node->which = 0;
191 nr_node->count = 1;
192 atomic_set(&nr_node->refcount, 1);
193 spin_lock_init(&nr_node->node_lock);
195 nr_node->routes[0].quality = quality;
196 nr_node->routes[0].obs_count = obs_count;
197 nr_node->routes[0].neighbour = nr_neigh;
199 nr_neigh_hold(nr_neigh);
200 nr_neigh->count++;
202 spin_lock_bh(&nr_node_list_lock);
203 hlist_add_head(&nr_node->node_node, &nr_node_list);
204 /* refcount initialized at 1 */
205 spin_unlock_bh(&nr_node_list_lock);
207 return 0;
209 nr_node_lock(nr_node);
211 if (quality != 0)
212 strcpy(nr_node->mnemonic, mnemonic);
214 for (found = 0, i = 0; i < nr_node->count; i++) {
215 if (nr_node->routes[i].neighbour == nr_neigh) {
216 nr_node->routes[i].quality = quality;
217 nr_node->routes[i].obs_count = obs_count;
218 found = 1;
219 break;
223 if (!found) {
224 /* We have space at the bottom, slot it in */
225 if (nr_node->count < 3) {
226 nr_node->routes[2] = nr_node->routes[1];
227 nr_node->routes[1] = nr_node->routes[0];
229 nr_node->routes[0].quality = quality;
230 nr_node->routes[0].obs_count = obs_count;
231 nr_node->routes[0].neighbour = nr_neigh;
233 nr_node->which++;
234 nr_node->count++;
235 nr_neigh_hold(nr_neigh);
236 nr_neigh->count++;
237 } else {
238 /* It must be better than the worst */
239 if (quality > nr_node->routes[2].quality) {
240 nr_node->routes[2].neighbour->count--;
241 nr_neigh_put(nr_node->routes[2].neighbour);
243 if (nr_node->routes[2].neighbour->count == 0 && !nr_node->routes[2].neighbour->locked)
244 nr_remove_neigh(nr_node->routes[2].neighbour);
246 nr_node->routes[2].quality = quality;
247 nr_node->routes[2].obs_count = obs_count;
248 nr_node->routes[2].neighbour = nr_neigh;
250 nr_neigh_hold(nr_neigh);
251 nr_neigh->count++;
256 /* Now re-sort the routes in quality order */
257 switch (nr_node->count) {
258 case 3:
259 if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
260 switch (nr_node->which) {
261 case 0:
262 nr_node->which = 1;
263 break;
264 case 1:
265 nr_node->which = 0;
266 break;
268 nr_route = nr_node->routes[0];
269 nr_node->routes[0] = nr_node->routes[1];
270 nr_node->routes[1] = nr_route;
272 if (nr_node->routes[2].quality > nr_node->routes[1].quality) {
273 switch (nr_node->which) {
274 case 1: nr_node->which = 2;
275 break;
277 case 2: nr_node->which = 1;
278 break;
280 default:
281 break;
283 nr_route = nr_node->routes[1];
284 nr_node->routes[1] = nr_node->routes[2];
285 nr_node->routes[2] = nr_route;
287 case 2:
288 if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
289 switch (nr_node->which) {
290 case 0: nr_node->which = 1;
291 break;
293 case 1: nr_node->which = 0;
294 break;
296 default: break;
298 nr_route = nr_node->routes[0];
299 nr_node->routes[0] = nr_node->routes[1];
300 nr_node->routes[1] = nr_route;
302 case 1:
303 break;
306 for (i = 0; i < nr_node->count; i++) {
307 if (nr_node->routes[i].neighbour == nr_neigh) {
308 if (i < nr_node->which)
309 nr_node->which = i;
310 break;
314 nr_neigh_put(nr_neigh);
315 nr_node_unlock(nr_node);
316 nr_node_put(nr_node);
317 return 0;
320 static inline void __nr_remove_node(struct nr_node *nr_node)
322 hlist_del_init(&nr_node->node_node);
323 nr_node_put(nr_node);
326 #define nr_remove_node_locked(__node) \
327 __nr_remove_node(__node)
329 static void nr_remove_node(struct nr_node *nr_node)
331 spin_lock_bh(&nr_node_list_lock);
332 __nr_remove_node(nr_node);
333 spin_unlock_bh(&nr_node_list_lock);
336 static inline void __nr_remove_neigh(struct nr_neigh *nr_neigh)
338 hlist_del_init(&nr_neigh->neigh_node);
339 nr_neigh_put(nr_neigh);
342 #define nr_remove_neigh_locked(__neigh) \
343 __nr_remove_neigh(__neigh)
345 static void nr_remove_neigh(struct nr_neigh *nr_neigh)
347 spin_lock_bh(&nr_neigh_list_lock);
348 __nr_remove_neigh(nr_neigh);
349 spin_unlock_bh(&nr_neigh_list_lock);
353 * "Delete" a node. Strictly speaking remove a route to a node. The node
354 * is only deleted if no routes are left to it.
356 static int nr_del_node(ax25_address *callsign, ax25_address *neighbour, struct net_device *dev)
358 struct nr_node *nr_node;
359 struct nr_neigh *nr_neigh;
360 int i;
362 nr_node = nr_node_get(callsign);
364 if (nr_node == NULL)
365 return -EINVAL;
367 nr_neigh = nr_neigh_get_dev(neighbour, dev);
369 if (nr_neigh == NULL) {
370 nr_node_put(nr_node);
371 return -EINVAL;
374 nr_node_lock(nr_node);
375 for (i = 0; i < nr_node->count; i++) {
376 if (nr_node->routes[i].neighbour == nr_neigh) {
377 nr_neigh->count--;
378 nr_neigh_put(nr_neigh);
380 if (nr_neigh->count == 0 && !nr_neigh->locked)
381 nr_remove_neigh(nr_neigh);
382 nr_neigh_put(nr_neigh);
384 nr_node->count--;
386 if (nr_node->count == 0) {
387 nr_remove_node(nr_node);
388 } else {
389 switch (i) {
390 case 0:
391 nr_node->routes[0] = nr_node->routes[1];
392 case 1:
393 nr_node->routes[1] = nr_node->routes[2];
394 case 2:
395 break;
397 nr_node_put(nr_node);
399 nr_node_unlock(nr_node);
401 return 0;
404 nr_neigh_put(nr_neigh);
405 nr_node_unlock(nr_node);
406 nr_node_put(nr_node);
408 return -EINVAL;
412 * Lock a neighbour with a quality.
414 static int __must_check nr_add_neigh(ax25_address *callsign,
415 ax25_digi *ax25_digi, struct net_device *dev, unsigned int quality)
417 struct nr_neigh *nr_neigh;
419 nr_neigh = nr_neigh_get_dev(callsign, dev);
420 if (nr_neigh) {
421 nr_neigh->quality = quality;
422 nr_neigh->locked = 1;
423 nr_neigh_put(nr_neigh);
424 return 0;
427 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
428 return -ENOMEM;
430 nr_neigh->callsign = *callsign;
431 nr_neigh->digipeat = NULL;
432 nr_neigh->ax25 = NULL;
433 nr_neigh->dev = dev;
434 nr_neigh->quality = quality;
435 nr_neigh->locked = 1;
436 nr_neigh->count = 0;
437 nr_neigh->number = nr_neigh_no++;
438 nr_neigh->failed = 0;
439 atomic_set(&nr_neigh->refcount, 1);
441 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
442 nr_neigh->digipeat = kmemdup(ax25_digi, sizeof(*ax25_digi),
443 GFP_KERNEL);
444 if (nr_neigh->digipeat == NULL) {
445 kfree(nr_neigh);
446 return -ENOMEM;
450 spin_lock_bh(&nr_neigh_list_lock);
451 hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
452 /* refcount is initialized at 1 */
453 spin_unlock_bh(&nr_neigh_list_lock);
455 return 0;
459 * "Delete" a neighbour. The neighbour is only removed if the number
460 * of nodes that may use it is zero.
462 static int nr_del_neigh(ax25_address *callsign, struct net_device *dev, unsigned int quality)
464 struct nr_neigh *nr_neigh;
466 nr_neigh = nr_neigh_get_dev(callsign, dev);
468 if (nr_neigh == NULL) return -EINVAL;
470 nr_neigh->quality = quality;
471 nr_neigh->locked = 0;
473 if (nr_neigh->count == 0)
474 nr_remove_neigh(nr_neigh);
475 nr_neigh_put(nr_neigh);
477 return 0;
481 * Decrement the obsolescence count by one. If a route is reduced to a
482 * count of zero, remove it. Also remove any unlocked neighbours with
483 * zero nodes routing via it.
485 static int nr_dec_obs(void)
487 struct nr_neigh *nr_neigh;
488 struct nr_node *s;
489 struct hlist_node *node, *nodet;
490 int i;
492 spin_lock_bh(&nr_node_list_lock);
493 nr_node_for_each_safe(s, node, nodet, &nr_node_list) {
494 nr_node_lock(s);
495 for (i = 0; i < s->count; i++) {
496 switch (s->routes[i].obs_count) {
497 case 0: /* A locked entry */
498 break;
500 case 1: /* From 1 -> 0 */
501 nr_neigh = s->routes[i].neighbour;
503 nr_neigh->count--;
504 nr_neigh_put(nr_neigh);
506 if (nr_neigh->count == 0 && !nr_neigh->locked)
507 nr_remove_neigh(nr_neigh);
509 s->count--;
511 switch (i) {
512 case 0:
513 s->routes[0] = s->routes[1];
514 /* Fallthrough */
515 case 1:
516 s->routes[1] = s->routes[2];
517 case 2:
518 break;
520 break;
522 default:
523 s->routes[i].obs_count--;
524 break;
529 if (s->count <= 0)
530 nr_remove_node_locked(s);
531 nr_node_unlock(s);
533 spin_unlock_bh(&nr_node_list_lock);
535 return 0;
539 * A device has been removed. Remove its routes and neighbours.
541 void nr_rt_device_down(struct net_device *dev)
543 struct nr_neigh *s;
544 struct hlist_node *node, *nodet, *node2, *node2t;
545 struct nr_node *t;
546 int i;
548 spin_lock_bh(&nr_neigh_list_lock);
549 nr_neigh_for_each_safe(s, node, nodet, &nr_neigh_list) {
550 if (s->dev == dev) {
551 spin_lock_bh(&nr_node_list_lock);
552 nr_node_for_each_safe(t, node2, node2t, &nr_node_list) {
553 nr_node_lock(t);
554 for (i = 0; i < t->count; i++) {
555 if (t->routes[i].neighbour == s) {
556 t->count--;
558 switch (i) {
559 case 0:
560 t->routes[0] = t->routes[1];
561 case 1:
562 t->routes[1] = t->routes[2];
563 case 2:
564 break;
569 if (t->count <= 0)
570 nr_remove_node_locked(t);
571 nr_node_unlock(t);
573 spin_unlock_bh(&nr_node_list_lock);
575 nr_remove_neigh_locked(s);
578 spin_unlock_bh(&nr_neigh_list_lock);
582 * Check that the device given is a valid AX.25 interface that is "up".
583 * Or a valid ethernet interface with an AX.25 callsign binding.
585 static struct net_device *nr_ax25_dev_get(char *devname)
587 struct net_device *dev;
589 if ((dev = dev_get_by_name(&init_net, devname)) == NULL)
590 return NULL;
592 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
593 return dev;
595 dev_put(dev);
596 return NULL;
600 * Find the first active NET/ROM device, usually "nr0".
602 struct net_device *nr_dev_first(void)
604 struct net_device *dev, *first = NULL;
606 rcu_read_lock();
607 for_each_netdev_rcu(&init_net, dev) {
608 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM)
609 if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
610 first = dev;
612 if (first)
613 dev_hold(first);
614 rcu_read_unlock();
616 return first;
620 * Find the NET/ROM device for the given callsign.
622 struct net_device *nr_dev_get(ax25_address *addr)
624 struct net_device *dev;
626 rcu_read_lock();
627 for_each_netdev_rcu(&init_net, dev) {
628 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM &&
629 ax25cmp(addr, (ax25_address *)dev->dev_addr) == 0) {
630 dev_hold(dev);
631 goto out;
634 dev = NULL;
635 out:
636 rcu_read_unlock();
637 return dev;
640 static ax25_digi *nr_call_to_digi(ax25_digi *digi, int ndigis,
641 ax25_address *digipeaters)
643 int i;
645 if (ndigis == 0)
646 return NULL;
648 for (i = 0; i < ndigis; i++) {
649 digi->calls[i] = digipeaters[i];
650 digi->repeated[i] = 0;
653 digi->ndigi = ndigis;
654 digi->lastrepeat = -1;
656 return digi;
660 * Handle the ioctls that control the routing functions.
662 int nr_rt_ioctl(unsigned int cmd, void __user *arg)
664 struct nr_route_struct nr_route;
665 struct net_device *dev;
666 ax25_digi digi;
667 int ret;
669 switch (cmd) {
670 case SIOCADDRT:
671 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
672 return -EFAULT;
673 if (nr_route.ndigis > AX25_MAX_DIGIS)
674 return -EINVAL;
675 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
676 return -EINVAL;
677 switch (nr_route.type) {
678 case NETROM_NODE:
679 if (strnlen(nr_route.mnemonic, 7) == 7) {
680 ret = -EINVAL;
681 break;
684 ret = nr_add_node(&nr_route.callsign,
685 nr_route.mnemonic,
686 &nr_route.neighbour,
687 nr_call_to_digi(&digi, nr_route.ndigis,
688 nr_route.digipeaters),
689 dev, nr_route.quality,
690 nr_route.obs_count);
691 break;
692 case NETROM_NEIGH:
693 ret = nr_add_neigh(&nr_route.callsign,
694 nr_call_to_digi(&digi, nr_route.ndigis,
695 nr_route.digipeaters),
696 dev, nr_route.quality);
697 break;
698 default:
699 ret = -EINVAL;
701 dev_put(dev);
702 return ret;
704 case SIOCDELRT:
705 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
706 return -EFAULT;
707 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
708 return -EINVAL;
709 switch (nr_route.type) {
710 case NETROM_NODE:
711 ret = nr_del_node(&nr_route.callsign,
712 &nr_route.neighbour, dev);
713 break;
714 case NETROM_NEIGH:
715 ret = nr_del_neigh(&nr_route.callsign,
716 dev, nr_route.quality);
717 break;
718 default:
719 ret = -EINVAL;
721 dev_put(dev);
722 return ret;
724 case SIOCNRDECOBS:
725 return nr_dec_obs();
727 default:
728 return -EINVAL;
731 return 0;
735 * A level 2 link has timed out, therefore it appears to be a poor link,
736 * then don't use that neighbour until it is reset.
738 void nr_link_failed(ax25_cb *ax25, int reason)
740 struct nr_neigh *s, *nr_neigh = NULL;
741 struct hlist_node *node;
742 struct nr_node *nr_node = NULL;
744 spin_lock_bh(&nr_neigh_list_lock);
745 nr_neigh_for_each(s, node, &nr_neigh_list) {
746 if (s->ax25 == ax25) {
747 nr_neigh_hold(s);
748 nr_neigh = s;
749 break;
752 spin_unlock_bh(&nr_neigh_list_lock);
754 if (nr_neigh == NULL)
755 return;
757 nr_neigh->ax25 = NULL;
758 ax25_cb_put(ax25);
760 if (++nr_neigh->failed < sysctl_netrom_link_fails_count) {
761 nr_neigh_put(nr_neigh);
762 return;
764 spin_lock_bh(&nr_node_list_lock);
765 nr_node_for_each(nr_node, node, &nr_node_list) {
766 nr_node_lock(nr_node);
767 if (nr_node->which < nr_node->count &&
768 nr_node->routes[nr_node->which].neighbour == nr_neigh)
769 nr_node->which++;
770 nr_node_unlock(nr_node);
772 spin_unlock_bh(&nr_node_list_lock);
773 nr_neigh_put(nr_neigh);
777 * Route a frame to an appropriate AX.25 connection. A NULL ax25_cb
778 * indicates an internally generated frame.
780 int nr_route_frame(struct sk_buff *skb, ax25_cb *ax25)
782 ax25_address *nr_src, *nr_dest;
783 struct nr_neigh *nr_neigh;
784 struct nr_node *nr_node;
785 struct net_device *dev;
786 unsigned char *dptr;
787 ax25_cb *ax25s;
788 int ret;
789 struct sk_buff *skbn;
792 nr_src = (ax25_address *)(skb->data + 0);
793 nr_dest = (ax25_address *)(skb->data + 7);
795 if (ax25 != NULL) {
796 ret = nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
797 ax25->ax25_dev->dev, 0,
798 sysctl_netrom_obsolescence_count_initialiser);
799 if (ret)
800 return ret;
803 if ((dev = nr_dev_get(nr_dest)) != NULL) { /* Its for me */
804 if (ax25 == NULL) /* Its from me */
805 ret = nr_loopback_queue(skb);
806 else
807 ret = nr_rx_frame(skb, dev);
808 dev_put(dev);
809 return ret;
812 if (!sysctl_netrom_routing_control && ax25 != NULL)
813 return 0;
815 /* Its Time-To-Live has expired */
816 if (skb->data[14] == 1) {
817 return 0;
820 nr_node = nr_node_get(nr_dest);
821 if (nr_node == NULL)
822 return 0;
823 nr_node_lock(nr_node);
825 if (nr_node->which >= nr_node->count) {
826 nr_node_unlock(nr_node);
827 nr_node_put(nr_node);
828 return 0;
831 nr_neigh = nr_node->routes[nr_node->which].neighbour;
833 if ((dev = nr_dev_first()) == NULL) {
834 nr_node_unlock(nr_node);
835 nr_node_put(nr_node);
836 return 0;
839 /* We are going to change the netrom headers so we should get our
840 own skb, we also did not know until now how much header space
841 we had to reserve... - RXQ */
842 if ((skbn=skb_copy_expand(skb, dev->hard_header_len, 0, GFP_ATOMIC)) == NULL) {
843 nr_node_unlock(nr_node);
844 nr_node_put(nr_node);
845 dev_put(dev);
846 return 0;
848 kfree_skb(skb);
849 skb=skbn;
850 skb->data[14]--;
852 dptr = skb_push(skb, 1);
853 *dptr = AX25_P_NETROM;
855 ax25s = nr_neigh->ax25;
856 nr_neigh->ax25 = ax25_send_frame(skb, 256,
857 (ax25_address *)dev->dev_addr,
858 &nr_neigh->callsign,
859 nr_neigh->digipeat, nr_neigh->dev);
860 if (ax25s)
861 ax25_cb_put(ax25s);
863 dev_put(dev);
864 ret = (nr_neigh->ax25 != NULL);
865 nr_node_unlock(nr_node);
866 nr_node_put(nr_node);
868 return ret;
871 #ifdef CONFIG_PROC_FS
873 static void *nr_node_start(struct seq_file *seq, loff_t *pos)
875 spin_lock_bh(&nr_node_list_lock);
876 return seq_hlist_start_head(&nr_node_list, *pos);
879 static void *nr_node_next(struct seq_file *seq, void *v, loff_t *pos)
881 return seq_hlist_next(v, &nr_node_list, pos);
884 static void nr_node_stop(struct seq_file *seq, void *v)
886 spin_unlock_bh(&nr_node_list_lock);
889 static int nr_node_show(struct seq_file *seq, void *v)
891 char buf[11];
892 int i;
894 if (v == SEQ_START_TOKEN)
895 seq_puts(seq,
896 "callsign mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
897 else {
898 struct nr_node *nr_node = hlist_entry(v, struct nr_node,
899 node_node);
901 nr_node_lock(nr_node);
902 seq_printf(seq, "%-9s %-7s %d %d",
903 ax2asc(buf, &nr_node->callsign),
904 (nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
905 nr_node->which + 1,
906 nr_node->count);
908 for (i = 0; i < nr_node->count; i++) {
909 seq_printf(seq, " %3d %d %05d",
910 nr_node->routes[i].quality,
911 nr_node->routes[i].obs_count,
912 nr_node->routes[i].neighbour->number);
914 nr_node_unlock(nr_node);
916 seq_puts(seq, "\n");
918 return 0;
921 static const struct seq_operations nr_node_seqops = {
922 .start = nr_node_start,
923 .next = nr_node_next,
924 .stop = nr_node_stop,
925 .show = nr_node_show,
928 static int nr_node_info_open(struct inode *inode, struct file *file)
930 return seq_open(file, &nr_node_seqops);
933 const struct file_operations nr_nodes_fops = {
934 .owner = THIS_MODULE,
935 .open = nr_node_info_open,
936 .read = seq_read,
937 .llseek = seq_lseek,
938 .release = seq_release,
941 static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
943 spin_lock_bh(&nr_neigh_list_lock);
944 return seq_hlist_start_head(&nr_neigh_list, *pos);
947 static void *nr_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
949 return seq_hlist_next(v, &nr_neigh_list, pos);
952 static void nr_neigh_stop(struct seq_file *seq, void *v)
954 spin_unlock_bh(&nr_neigh_list_lock);
957 static int nr_neigh_show(struct seq_file *seq, void *v)
959 char buf[11];
960 int i;
962 if (v == SEQ_START_TOKEN)
963 seq_puts(seq, "addr callsign dev qual lock count failed digipeaters\n");
964 else {
965 struct nr_neigh *nr_neigh;
967 nr_neigh = hlist_entry(v, struct nr_neigh, neigh_node);
968 seq_printf(seq, "%05d %-9s %-4s %3d %d %3d %3d",
969 nr_neigh->number,
970 ax2asc(buf, &nr_neigh->callsign),
971 nr_neigh->dev ? nr_neigh->dev->name : "???",
972 nr_neigh->quality,
973 nr_neigh->locked,
974 nr_neigh->count,
975 nr_neigh->failed);
977 if (nr_neigh->digipeat != NULL) {
978 for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
979 seq_printf(seq, " %s",
980 ax2asc(buf, &nr_neigh->digipeat->calls[i]));
983 seq_puts(seq, "\n");
985 return 0;
988 static const struct seq_operations nr_neigh_seqops = {
989 .start = nr_neigh_start,
990 .next = nr_neigh_next,
991 .stop = nr_neigh_stop,
992 .show = nr_neigh_show,
995 static int nr_neigh_info_open(struct inode *inode, struct file *file)
997 return seq_open(file, &nr_neigh_seqops);
1000 const struct file_operations nr_neigh_fops = {
1001 .owner = THIS_MODULE,
1002 .open = nr_neigh_info_open,
1003 .read = seq_read,
1004 .llseek = seq_lseek,
1005 .release = seq_release,
1008 #endif
1011 * Free all memory associated with the nodes and routes lists.
1013 void __exit nr_rt_free(void)
1015 struct nr_neigh *s = NULL;
1016 struct nr_node *t = NULL;
1017 struct hlist_node *node, *nodet;
1019 spin_lock_bh(&nr_neigh_list_lock);
1020 spin_lock_bh(&nr_node_list_lock);
1021 nr_node_for_each_safe(t, node, nodet, &nr_node_list) {
1022 nr_node_lock(t);
1023 nr_remove_node_locked(t);
1024 nr_node_unlock(t);
1026 nr_neigh_for_each_safe(s, node, nodet, &nr_neigh_list) {
1027 while(s->count) {
1028 s->count--;
1029 nr_neigh_put(s);
1031 nr_remove_neigh_locked(s);
1033 spin_unlock_bh(&nr_node_list_lock);
1034 spin_unlock_bh(&nr_neigh_list_lock);