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