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