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