?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pre-2.3.4..
[davej-history.git] / net / netrom / nr_route.c
blob4041967db4ba050e27435b04cf4b8a72de5254c3
1 /*
2 * NET/ROM release 007
3 *
4 * This code REQUIRES 2.1.15 or higher/ NET3.038
5 *
6 * This module:
7 * This module is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * History
13 * NET/ROM 001 Jonathan(G4KLX) First attempt.
14 * NET/ROM 003 Jonathan(G4KLX) Use SIOCADDRT/SIOCDELRT ioctl values
15 * for NET/ROM routes.
16 * Use '*' for a blank mnemonic in /proc/net/nr_nodes.
17 * Change default quality for new neighbour when same
18 * as node callsign.
19 * Alan Cox(GW4PTS) Added the firewall hooks.
20 * NET/ROM 006 Jonathan(G4KLX) Added the setting of digipeated neighbours.
21 * Tomi(OH2BNS) Routing quality and link failure changes.
22 */
23
24 #include <linux/config.h>
25 #if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE)
26 #include <linux/errno.h>
27 #include <linux/types.h>
28 #include <linux/socket.h>
29 #include <linux/in.h>
30 #include <linux/kernel.h>
31 #include <linux/sched.h>
32 #include <linux/timer.h>
33 #include <linux/string.h>
34 #include <linux/sockios.h>
35 #include <linux/net.h>
36 #include <net/ax25.h>
37 #include <linux/inet.h>
38 #include <linux/netdevice.h>
39 #include <net/arp.h>
40 #include <linux/if_arp.h>
41 #include <linux/skbuff.h>
42 #include <net/sock.h>
43 #include <asm/uaccess.h>
44 #include <asm/system.h>
45 #include <linux/fcntl.h>
46 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
47 #include <linux/mm.h>
48 #include <linux/interrupt.h>
49 #include <linux/notifier.h>
50 #include <linux/firewall.h>
51 #include <net/netrom.h>
52
53 static unsigned int nr_neigh_no = 1;
54
55 static struct nr_node *nr_node_list = NULL;
56 static struct nr_neigh *nr_neigh_list = NULL;
57
58 static void nr_remove_neigh(struct nr_neigh *);
59
60 /*
61 * Add a new route to a node, and in the process add the node and the
62 * neighbour if it is new.
63 */
64 static int nr_add_node(ax25_address *nr, const char *mnemonic, ax25_address *ax25,
65 ax25_digi *ax25_digi, struct device *dev, int quality, int obs_count)
66 {
67 struct nr_node *nr_node;
68 struct nr_neigh *nr_neigh;
69 struct nr_route nr_route;
70 unsigned long flags;
71 int i, found;
72
73 if (nr_dev_get(nr) != NULL) /* Can't add routes to ourself */
74 return -EINVAL;
75
76 for (nr_node = nr_node_list; nr_node != NULL; nr_node = nr_node->next)
77 if (ax25cmp(nr, &nr_node->callsign) == 0)
78 break;
79
80 for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next)
81 if (ax25cmp(ax25, &nr_neigh->callsign) == 0 && nr_neigh->dev == dev)
82 break;
83
84 /*
85 * The L2 link to a neighbour has failed in the past
86 * and now a frame comes from this neighbour. We assume
87 * it was a temporary trouble with the link and reset the
88 * routes now (and not wait for a node broadcast).
89 */
90 if (nr_neigh != NULL && nr_neigh->failed != 0 && quality == 0) {
91 struct nr_node *node;
92
93 for (node = nr_node_list; node != NULL; node = node->next)
94 for (i = 0; i < node->count; i++)
95 if (node->routes[i].neighbour == nr_neigh)
96 if (i < node->which)
97 node->which = i;
98 }
99
100 if (nr_neigh != NULL)
101 nr_neigh->failed = 0;
102
103 if (quality == 0 && nr_neigh != NULL && nr_node != NULL)
104 return 0;
105
106 if (nr_neigh == NULL) {
107 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
108 return -ENOMEM;
109
110 nr_neigh->callsign = *ax25;
111 nr_neigh->digipeat = NULL;
112 nr_neigh->ax25 = NULL;
113 nr_neigh->dev = dev;
114 nr_neigh->quality = sysctl_netrom_default_path_quality;
115 nr_neigh->locked = 0;
116 nr_neigh->count = 0;
117 nr_neigh->number = nr_neigh_no++;
118 nr_neigh->failed = 0;
119
120 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
121 if ((nr_neigh->digipeat = kmalloc(sizeof(*ax25_digi), GFP_KERNEL)) == NULL) {
122 kfree(nr_neigh);
123 return -ENOMEM;
124 }
125 *nr_neigh->digipeat = *ax25_digi;
126 }
127
128 save_flags(flags);
129 cli();
130
131 nr_neigh->next = nr_neigh_list;
132 nr_neigh_list = nr_neigh;
133
134 restore_flags(flags);
135 }
136
137 if (quality != 0 && ax25cmp(nr, ax25) == 0 && !nr_neigh->locked)
138 nr_neigh->quality = quality;
139
140 if (nr_node == NULL) {
141 if ((nr_node = kmalloc(sizeof(*nr_node), GFP_ATOMIC)) == NULL)
142 return -ENOMEM;
143
144 nr_node->callsign = *nr;
145 strcpy(nr_node->mnemonic, mnemonic);
146
147 nr_node->which = 0;
148 nr_node->count = 1;
149
150 nr_node->routes[0].quality = quality;
151 nr_node->routes[0].obs_count = obs_count;
152 nr_node->routes[0].neighbour = nr_neigh;
153
154 save_flags(flags);
155 cli();
156
157 nr_node->next = nr_node_list;
158 nr_node_list = nr_node;
159
160 restore_flags(flags);
161
162 nr_neigh->count++;
163
164 return 0;
165 }
166
167 if (quality != 0)
168 strcpy(nr_node->mnemonic, mnemonic);
169
170 for (found = 0, i = 0; i < nr_node->count; i++) {
171 if (nr_node->routes[i].neighbour == nr_neigh) {
172 nr_node->routes[i].quality = quality;
173 nr_node->routes[i].obs_count = obs_count;
174 found = 1;
175 break;
176 }
177 }
178
179 if (!found) {
180 /* We have space at the bottom, slot it in */
181 if (nr_node->count < 3) {
182 nr_node->routes[2] = nr_node->routes[1];
183 nr_node->routes[1] = nr_node->routes[0];
184
185 nr_node->routes[0].quality = quality;
186 nr_node->routes[0].obs_count = obs_count;
187 nr_node->routes[0].neighbour = nr_neigh;
188
189 nr_node->which++;
190 nr_node->count++;
191 nr_neigh->count++;
192 } else {
193 /* It must be better than the worst */
194 if (quality > nr_node->routes[2].quality) {
195 nr_node->routes[2].neighbour->count--;
196
197 if (nr_node->routes[2].neighbour->count == 0 && !nr_node->routes[2].neighbour->locked)
198 nr_remove_neigh(nr_node->routes[2].neighbour);
199
200 nr_node->routes[2].quality = quality;
201 nr_node->routes[2].obs_count = obs_count;
202 nr_node->routes[2].neighbour = nr_neigh;
203
204 nr_neigh->count++;
205 }
206 }
207 }
208
209 /* Now re-sort the routes in quality order */
210 switch (nr_node->count) {
211 case 3:
212 if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
213 switch (nr_node->which) {
214 case 0: nr_node->which = 1; break;
215 case 1: nr_node->which = 0; break;
216 default: break;
217 }
218 nr_route = nr_node->routes[0];
219 nr_node->routes[0] = nr_node->routes[1];
220 nr_node->routes[1] = nr_route;
221 }
222 if (nr_node->routes[2].quality > nr_node->routes[1].quality) {
223 switch (nr_node->which) {
224 case 1: nr_node->which = 2; break;
225 case 2: nr_node->which = 1; break;
226 default: break;
227 }
228 nr_route = nr_node->routes[1];
229 nr_node->routes[1] = nr_node->routes[2];
230 nr_node->routes[2] = nr_route;
231 }
232 case 2:
233 if (nr_node->routes[1].quality > nr_node->routes[0].quality) {
234 switch (nr_node->which) {
235 case 0: nr_node->which = 1; break;
236 case 1: nr_node->which = 0; break;
237 default: break;
238 }
239 nr_route = nr_node->routes[0];
240 nr_node->routes[0] = nr_node->routes[1];
241 nr_node->routes[1] = nr_route;
242 }
243 case 1:
244 break;
245 }
246
247 for (i = 0; i < nr_node->count; i++) {
248 if (nr_node->routes[i].neighbour == nr_neigh) {
249 if (i < nr_node->which)
250 nr_node->which = i;
251 break;
252 }
253 }
254
255 return 0;
256 }
257
258 static void nr_remove_node(struct nr_node *nr_node)
259 {
260 struct nr_node *s;
261 unsigned long flags;
262
263 save_flags(flags);
264 cli();
265
266 if ((s = nr_node_list) == nr_node) {
267 nr_node_list = nr_node->next;
268 restore_flags(flags);
269 kfree(nr_node);
270 return;
271 }
272
273 while (s != NULL && s->next != NULL) {
274 if (s->next == nr_node) {
275 s->next = nr_node->next;
276 restore_flags(flags);
277 kfree(nr_node);
278 return;
279 }
280
281 s = s->next;
282 }
283
284 restore_flags(flags);
285 }
286
287 static void nr_remove_neigh(struct nr_neigh *nr_neigh)
288 {
289 struct nr_neigh *s;
290 unsigned long flags;
291
292 save_flags(flags);
293 cli();
294
295 if ((s = nr_neigh_list) == nr_neigh) {
296 nr_neigh_list = nr_neigh->next;
297 restore_flags(flags);
298 if (nr_neigh->digipeat != NULL)
299 kfree(nr_neigh->digipeat);
300 kfree(nr_neigh);
301 return;
302 }
303
304 while (s != NULL && s->next != NULL) {
305 if (s->next == nr_neigh) {
306 s->next = nr_neigh->next;
307 restore_flags(flags);
308 if (nr_neigh->digipeat != NULL)
309 kfree(nr_neigh->digipeat);
310 kfree(nr_neigh);
311 return;
312 }
313
314 s = s->next;
315 }
316
317 restore_flags(flags);
318 }
319
320 /*
321 * "Delete" a node. Strictly speaking remove a route to a node. The node
322 * is only deleted if no routes are left to it.
323 */
324 static int nr_del_node(ax25_address *callsign, ax25_address *neighbour, struct device *dev)
325 {
326 struct nr_node *nr_node;
327 struct nr_neigh *nr_neigh;
328 int i;
329
330 for (nr_node = nr_node_list; nr_node != NULL; nr_node = nr_node->next)
331 if (ax25cmp(callsign, &nr_node->callsign) == 0)
332 break;
333
334 if (nr_node == NULL) return -EINVAL;
335
336 for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next)
337 if (ax25cmp(neighbour, &nr_neigh->callsign) == 0 && nr_neigh->dev == dev)
338 break;
339
340 if (nr_neigh == NULL) return -EINVAL;
341
342 for (i = 0; i < nr_node->count; i++) {
343 if (nr_node->routes[i].neighbour == nr_neigh) {
344 nr_neigh->count--;
345
346 if (nr_neigh->count == 0 && !nr_neigh->locked)
347 nr_remove_neigh(nr_neigh);
348
349 nr_node->count--;
350
351 if (nr_node->count == 0) {
352 nr_remove_node(nr_node);
353 } else {
354 switch (i) {
355 case 0:
356 nr_node->routes[0] = nr_node->routes[1];
357 case 1:
358 nr_node->routes[1] = nr_node->routes[2];
359 case 2:
360 break;
361 }
362 }
363
364 return 0;
365 }
366 }
367
368 return -EINVAL;
369 }
370
371 /*
372 * Lock a neighbour with a quality.
373 */
374 static int nr_add_neigh(ax25_address *callsign, ax25_digi *ax25_digi, struct device *dev, unsigned int quality)
375 {
376 struct nr_neigh *nr_neigh;
377 unsigned long flags;
378
379 for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next) {
380 if (ax25cmp(callsign, &nr_neigh->callsign) == 0 && nr_neigh->dev == dev) {
381 nr_neigh->quality = quality;
382 nr_neigh->locked = 1;
383 return 0;
384 }
385 }
386
387 if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
388 return -ENOMEM;
389
390 nr_neigh->callsign = *callsign;
391 nr_neigh->digipeat = NULL;
392 nr_neigh->ax25 = NULL;
393 nr_neigh->dev = dev;
394 nr_neigh->quality = quality;
395 nr_neigh->locked = 1;
396 nr_neigh->count = 0;
397 nr_neigh->number = nr_neigh_no++;
398 nr_neigh->failed = 0;
399
400 if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
401 if ((nr_neigh->digipeat = kmalloc(sizeof(*ax25_digi), GFP_KERNEL)) == NULL) {
402 kfree(nr_neigh);
403 return -ENOMEM;
404 }
405 *nr_neigh->digipeat = *ax25_digi;
406 }
407
408 save_flags(flags);
409 cli();
410
411 nr_neigh->next = nr_neigh_list;
412 nr_neigh_list = nr_neigh;
413
414 restore_flags(flags);
415
416 return 0;
417 }
418
419 /*
420 * "Delete" a neighbour. The neighbour is only removed if the number
421 * of nodes that may use it is zero.
422 */
423 static int nr_del_neigh(ax25_address *callsign, struct device *dev, unsigned int quality)
424 {
425 struct nr_neigh *nr_neigh;
426
427 for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next)
428 if (ax25cmp(callsign, &nr_neigh->callsign) == 0 && nr_neigh->dev == dev)
429 break;
430
431 if (nr_neigh == NULL) return -EINVAL;
432
433 nr_neigh->quality = quality;
434 nr_neigh->locked = 0;
435
436 if (nr_neigh->count == 0)
437 nr_remove_neigh(nr_neigh);
438
439 return 0;
440 }
441
442 /*
443 * Decrement the obsolescence count by one. If a route is reduced to a
444 * count of zero, remove it. Also remove any unlocked neighbours with
445 * zero nodes routing via it.
446 */
447 static int nr_dec_obs(void)
448 {
449 struct nr_neigh *nr_neigh;
450 struct nr_node *s, *nr_node;
451 int i;
452
453 nr_node = nr_node_list;
454
455 while (nr_node != NULL) {
456 s = nr_node;
457 nr_node = nr_node->next;
458
459 for (i = 0; i < s->count; i++) {
460 switch (s->routes[i].obs_count) {
461
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
470 if (nr_neigh->count == 0 && !nr_neigh->locked)
471 nr_remove_neigh(nr_neigh);
472
473 s->count--;
474
475 switch (i) {
476 case 0:
477 s->routes[0] = s->routes[1];
478 case 1:
479 s->routes[1] = s->routes[2];
480 case 2:
481 break;
482 }
483 break;
484
485 default:
486 s->routes[i].obs_count--;
487 break;
488
489 }
490 }
491
492 if (s->count <= 0)
493 nr_remove_node(s);
494 }
495
496 return 0;
497 }
498
499 /*
500 * A device has been removed. Remove its routes and neighbours.
501 */
502 void nr_rt_device_down(struct device *dev)
503 {
504 struct nr_neigh *s, *nr_neigh = nr_neigh_list;
505 struct nr_node *t, *nr_node;
506 int i;
507
508 while (nr_neigh != NULL) {
509 s = nr_neigh;
510 nr_neigh = nr_neigh->next;
511
512 if (s->dev == dev) {
513 nr_node = nr_node_list;
514
515 while (nr_node != NULL) {
516 t = nr_node;
517 nr_node = nr_node->next;
518
519 for (i = 0; i < t->count; i++) {
520 if (t->routes[i].neighbour == s) {
521 t->count--;
522
523 switch (i) {
524 case 0:
525 t->routes[0] = t->routes[1];
526 case 1:
527 t->routes[1] = t->routes[2];
528 case 2:
529 break;
530 }
531 }
532 }
533
534 if (t->count <= 0)
535 nr_remove_node(t);
536 }
537
538 nr_remove_neigh(s);
539 }
540 }
541 }
542
543 /*
544 * Check that the device given is a valid AX.25 interface that is "up".
545 * Or a valid ethernet interface with an AX.25 callsign binding.
546 */
547 static struct device *nr_ax25_dev_get(char *devname)
548 {
549 struct device *dev;
550
551 if ((dev = dev_get(devname)) == NULL)
552 return NULL;
553
554 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
555 return dev;
556
557 return NULL;
558 }
559
560 /*
561 * Find the first active NET/ROM device, usually "nr0".
562 */
563 struct device *nr_dev_first(void)
564 {
565 struct device *dev, *first = NULL;
566
567 read_lock_bh(&dev_base_lock);
568 for (dev = dev_base; dev != NULL; dev = dev->next) {
569 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM)
570 if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
571 first = dev;
572 }
573 read_unlock_bh(&dev_base_lock);
574
575 return first;
576 }
577
578 /*
579 * Find the NET/ROM device for the given callsign.
580 */
581 struct device *nr_dev_get(ax25_address *addr)
582 {
583 struct device *dev;
584
585 read_lock_bh(&dev_base_lock);
586 for (dev = dev_base; dev != NULL; dev = dev->next) {
587 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM && ax25cmp(addr, (ax25_address *)dev->dev_addr) == 0)
588 goto out;
589 }
590 out:
591 read_unlock_bh(&dev_base_lock);
592 return dev;
593 }
594
595 static ax25_digi *nr_call_to_digi(int ndigis, ax25_address *digipeaters)
596 {
597 static ax25_digi ax25_digi;
598 int i;
599
600 if (ndigis == 0)
601 return NULL;
602
603 for (i = 0; i < ndigis; i++) {
604 ax25_digi.calls[i] = digipeaters[i];
605 ax25_digi.repeated[i] = 0;
606 }
607
608 ax25_digi.ndigi = ndigis;
609 ax25_digi.lastrepeat = -1;
610
611 return &ax25_digi;
612 }
613
614 /*
615 * Handle the ioctls that control the routing functions.
616 */
617 int nr_rt_ioctl(unsigned int cmd, void *arg)
618 {
619 struct nr_route_struct nr_route;
620 struct device *dev;
621
622 switch (cmd) {
623
624 case SIOCADDRT:
625 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
626 return -EFAULT;
627 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
628 return -EINVAL;
629 if (nr_route.ndigis < 0 || nr_route.ndigis > AX25_MAX_DIGIS)
630 return -EINVAL;
631 switch (nr_route.type) {
632 case NETROM_NODE:
633 return nr_add_node(&nr_route.callsign,
634 nr_route.mnemonic,
635 &nr_route.neighbour,
636 nr_call_to_digi(nr_route.ndigis, nr_route.digipeaters),
637 dev, nr_route.quality,
638 nr_route.obs_count);
639 case NETROM_NEIGH:
640 return nr_add_neigh(&nr_route.callsign,
641 nr_call_to_digi(nr_route.ndigis, nr_route.digipeaters),
642 dev, nr_route.quality);
643 default:
644 return -EINVAL;
645 }
646
647 case SIOCDELRT:
648 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
649 return -EFAULT;
650 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
651 return -EINVAL;
652 switch (nr_route.type) {
653 case NETROM_NODE:
654 return nr_del_node(&nr_route.callsign,
655 &nr_route.neighbour, dev);
656 case NETROM_NEIGH:
657 return nr_del_neigh(&nr_route.callsign,
658 dev, nr_route.quality);
659 default:
660 return -EINVAL;
661 }
662
663 case SIOCNRDECOBS:
664 return nr_dec_obs();
665
666 default:
667 return -EINVAL;
668 }
669
670 return 0;
671 }
672
673 /*
674 * A level 2 link has timed out, therefore it appears to be a poor link,
675 * then don't use that neighbour until it is reset.
676 */
677 void nr_link_failed(ax25_cb *ax25, int reason)
678 {
679 struct nr_neigh *nr_neigh;
680 struct nr_node *nr_node;
681
682 for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next)
683 if (nr_neigh->ax25 == ax25)
684 break;
685
686 if (nr_neigh == NULL) return;
687
688 nr_neigh->ax25 = NULL;
689
690 if (++nr_neigh->failed < sysctl_netrom_link_fails_count) return;
691
692 for (nr_node = nr_node_list; nr_node != NULL; nr_node = nr_node->next)
693 if (nr_node->which < nr_node->count && nr_node->routes[nr_node->which].neighbour == nr_neigh)
694 nr_node->which++;
695 }
696
697 /*
698 * Route a frame to an appropriate AX.25 connection. A NULL ax25_cb
699 * indicates an internally generated frame.
700 */
701 int nr_route_frame(struct sk_buff *skb, ax25_cb *ax25)
702 {
703 ax25_address *nr_src, *nr_dest;
704 struct nr_neigh *nr_neigh;
705 struct nr_node *nr_node;
706 struct device *dev;
707 unsigned char *dptr;
708
709 if (ax25 != NULL && call_in_firewall(PF_NETROM, skb->dev, skb->data, NULL, &skb) != FW_ACCEPT)
710 return 0;
711
712 if (ax25 == NULL && call_out_firewall(PF_NETROM, skb->dev, skb->data, NULL, &skb) != FW_ACCEPT)
713 return 0;
714
715 nr_src = (ax25_address *)(skb->data + 0);
716 nr_dest = (ax25_address *)(skb->data + 7);
717
718 if (ax25 != NULL)
719 nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
720 ax25->ax25_dev->dev, 0, sysctl_netrom_obsolescence_count_initialiser);
721
722 if ((dev = nr_dev_get(nr_dest)) != NULL) { /* Its for me */
723 if (ax25 == NULL) /* Its from me */
724 return nr_loopback_queue(skb);
725 else
726 return nr_rx_frame(skb, dev);
727 }
728
729 if (!sysctl_netrom_routing_control && ax25 != NULL)
730 return 0;
731
732 /* Its Time-To-Live has expired */
733 if (--skb->data[14] == 0)
734 return 0;
735
736 for (nr_node = nr_node_list; nr_node != NULL; nr_node = nr_node->next)
737 if (ax25cmp(nr_dest, &nr_node->callsign) == 0)
738 break;
739
740 if (nr_node == NULL || nr_node->which >= nr_node->count)
741 return 0;
742
743 nr_neigh = nr_node->routes[nr_node->which].neighbour;
744
745 if ((dev = nr_dev_first()) == NULL)
746 return 0;
747
748 if (ax25 != NULL && call_fw_firewall(PF_NETROM, skb->dev, skb->data, NULL, &skb) != FW_ACCEPT)
749 return 0;
750
751 dptr = skb_push(skb, 1);
752 *dptr = AX25_P_NETROM;
753
754 nr_neigh->ax25 = ax25_send_frame(skb, 256, (ax25_address *)dev->dev_addr, &nr_neigh->callsign, nr_neigh->digipeat, nr_neigh->dev);
755
756 return (nr_neigh->ax25 != NULL);
757 }
758
759 int nr_nodes_get_info(char *buffer, char **start, off_t offset,
760 int length, int dummy)
761 {
762 struct nr_node *nr_node;
763 int len = 0;
764 off_t pos = 0;
765 off_t begin = 0;
766 int i;
767
768 cli();
769
770 len += sprintf(buffer, "callsign mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
771
772 for (nr_node = nr_node_list; nr_node != NULL; nr_node = nr_node->next) {
773 len += sprintf(buffer + len, "%-9s %-7s %d %d",
774 ax2asc(&nr_node->callsign),
775 (nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
776 nr_node->which + 1,
777 nr_node->count);
778
779 for (i = 0; i < nr_node->count; i++) {
780 len += sprintf(buffer + len, " %3d %d %05d",
781 nr_node->routes[i].quality,
782 nr_node->routes[i].obs_count,
783 nr_node->routes[i].neighbour->number);
784 }
785
786 len += sprintf(buffer + len, "\n");
787
788 pos = begin + len;
789
790 if (pos < offset) {
791 len = 0;
792 begin = pos;
793 }
794
795 if (pos > offset + length)
796 break;
797 }
798
799 sti();
800
801 *start = buffer + (offset - begin);
802 len -= (offset - begin);
803
804 if (len > length) len = length;
805
806 return len;
807 }
808
809 int nr_neigh_get_info(char *buffer, char **start, off_t offset,
810 int length, int dummy)
811 {
812 struct nr_neigh *nr_neigh;
813 int len = 0;
814 off_t pos = 0;
815 off_t begin = 0;
816 int i;
817
818 cli();
819
820 len += sprintf(buffer, "addr callsign dev qual lock count failed digipeaters\n");
821
822 for (nr_neigh = nr_neigh_list; nr_neigh != NULL; nr_neigh = nr_neigh->next) {
823 len += sprintf(buffer + len, "%05d %-9s %-4s %3d %d %3d %3d",
824 nr_neigh->number,
825 ax2asc(&nr_neigh->callsign),
826 nr_neigh->dev ? nr_neigh->dev->name : "???",
827 nr_neigh->quality,
828 nr_neigh->locked,
829 nr_neigh->count,
830 nr_neigh->failed);
831
832 if (nr_neigh->digipeat != NULL) {
833 for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
834 len += sprintf(buffer + len, " %s", ax2asc(&nr_neigh->digipeat->calls[i]));
835 }
836
837 len += sprintf(buffer + len, "\n");
838
839 pos = begin + len;
840
841 if (pos < offset) {
842 len = 0;
843 begin = pos;
844 }
845
846 if (pos > offset + length)
847 break;
848 }
849
850 sti();
851
852 *start = buffer + (offset - begin);
853 len -= (offset - begin);
854
855 if (len > length) len = length;
856
857 return len;
858 }
859
860 #ifdef MODULE
861
862 /*
863 * Free all memory associated with the nodes and routes lists.
864 */
865 void nr_rt_free(void)
866 {
867 struct nr_neigh *s, *nr_neigh = nr_neigh_list;
868 struct nr_node *t, *nr_node = nr_node_list;
869
870 while (nr_node != NULL) {
871 t = nr_node;
872 nr_node = nr_node->next;
873
874 nr_remove_node(t);
875 }
876
877 while (nr_neigh != NULL) {
878 s = nr_neigh;
879 nr_neigh = nr_neigh->next;
880
881 nr_remove_neigh(s);
882 }
883 }
884
885 #endif
886
887 #endif
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux