Pull fluff into release branch
[linux-2.6] / net / netrom / nr_route.c
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/timer.h>
17 #include <linux/string.h>
18 #include <linux/sockios.h>
19 #include <linux/net.h>
20 #include <net/ax25.h>
21 #include <linux/inet.h>
22 #include <linux/netdevice.h>
23 #include <net/arp.h>
24 #include <linux/if_arp.h>
25 #include <linux/skbuff.h>
26 #include <net/sock.h>
27 #include <asm/uaccess.h>
28 #include <asm/system.h>
29 #include <linux/fcntl.h>
30 #include <linux/termios.h>      /* For TIOCINQ/OUTQ */
31 #include <linux/mm.h>
32 #include <linux/interrupt.h>
33 #include <linux/notifier.h>
34 #include <linux/netfilter.h>
35 #include <linux/init.h>
36 #include <linux/spinlock.h>
37 #include <net/netrom.h>
38 #include <linux/seq_file.h>
39
40 static unsigned int nr_neigh_no = 1;
41
42 static HLIST_HEAD(nr_node_list);
43 static DEFINE_SPINLOCK(nr_node_list_lock);
44 static HLIST_HEAD(nr_neigh_list);
45 static DEFINE_SPINLOCK(nr_neigh_list_lock);
46
47 static struct nr_node *nr_node_get(ax25_address *callsign)
48 {
49         struct nr_node *found = NULL;
50         struct nr_node *nr_node;
51         struct hlist_node *node;
52
53         spin_lock_bh(&nr_node_list_lock);
54         nr_node_for_each(nr_node, node, &nr_node_list)
55                 if (ax25cmp(callsign, &nr_node->callsign) == 0) {
56                         nr_node_hold(nr_node);
57                         found = nr_node;
58                         break;
59                 }
60         spin_unlock_bh(&nr_node_list_lock);
61         return found;
62 }
63
64 static struct nr_neigh *nr_neigh_get_dev(ax25_address *callsign,
65                                          struct net_device *dev)
66 {
67         struct nr_neigh *found = NULL;
68         struct nr_neigh *nr_neigh;
69         struct hlist_node *node;
70
71         spin_lock_bh(&nr_neigh_list_lock);
72         nr_neigh_for_each(nr_neigh, node, &nr_neigh_list)
73                 if (ax25cmp(callsign, &nr_neigh->callsign) == 0 &&
74                     nr_neigh->dev == dev) {
75                         nr_neigh_hold(nr_neigh);
76                         found = nr_neigh;
77                         break;
78                 }
79         spin_unlock_bh(&nr_neigh_list_lock);
80         return found;
81 }
82
83 static void nr_remove_neigh(struct nr_neigh *);
84
85 /*
86  *      Add a new route to a node, and in the process add the node and the
87  *      neighbour if it is new.
88  */
89 static int __must_check nr_add_node(ax25_address *nr, const char *mnemonic,
90         ax25_address *ax25, ax25_digi *ax25_digi, struct net_device *dev,
91         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 __must_check nr_add_neigh(ax25_address *callsign,
410         ax25_digi *ax25_digi, struct net_device *dev, unsigned int quality)
411 {
412         struct nr_neigh *nr_neigh;
413
414         nr_neigh = nr_neigh_get_dev(callsign, dev);
415         if (nr_neigh) {
416                 nr_neigh->quality = quality;
417                 nr_neigh->locked  = 1;
418                 nr_neigh_put(nr_neigh);
419                 return 0;
420         }
421
422         if ((nr_neigh = kmalloc(sizeof(*nr_neigh), GFP_ATOMIC)) == NULL)
423                 return -ENOMEM;
424
425         nr_neigh->callsign = *callsign;
426         nr_neigh->digipeat = NULL;
427         nr_neigh->ax25     = NULL;
428         nr_neigh->dev      = dev;
429         nr_neigh->quality  = quality;
430         nr_neigh->locked   = 1;
431         nr_neigh->count    = 0;
432         nr_neigh->number   = nr_neigh_no++;
433         nr_neigh->failed   = 0;
434         atomic_set(&nr_neigh->refcount, 1);
435
436         if (ax25_digi != NULL && ax25_digi->ndigi > 0) {
437                 nr_neigh->digipeat = kmemdup(ax25_digi, sizeof(*ax25_digi),
438                                              GFP_KERNEL);
439                 if (nr_neigh->digipeat == NULL) {
440                         kfree(nr_neigh);
441                         return -ENOMEM;
442                 }
443         }
444
445         spin_lock_bh(&nr_neigh_list_lock);
446         hlist_add_head(&nr_neigh->neigh_node, &nr_neigh_list);
447         /* refcount is initialized at 1 */
448         spin_unlock_bh(&nr_neigh_list_lock);
449
450         return 0;
451 }
452
453 /*
454  *      "Delete" a neighbour. The neighbour is only removed if the number
455  *      of nodes that may use it is zero.
456  */
457 static int nr_del_neigh(ax25_address *callsign, struct net_device *dev, unsigned int quality)
458 {
459         struct nr_neigh *nr_neigh;
460
461         nr_neigh = nr_neigh_get_dev(callsign, dev);
462
463         if (nr_neigh == NULL) return -EINVAL;
464
465         nr_neigh->quality = quality;
466         nr_neigh->locked  = 0;
467
468         if (nr_neigh->count == 0)
469                 nr_remove_neigh(nr_neigh);
470         nr_neigh_put(nr_neigh);
471
472         return 0;
473 }
474
475 /*
476  *      Decrement the obsolescence count by one. If a route is reduced to a
477  *      count of zero, remove it. Also remove any unlocked neighbours with
478  *      zero nodes routing via it.
479  */
480 static int nr_dec_obs(void)
481 {
482         struct nr_neigh *nr_neigh;
483         struct nr_node  *s;
484         struct hlist_node *node, *nodet;
485         int i;
486
487         spin_lock_bh(&nr_node_list_lock);
488         nr_node_for_each_safe(s, node, nodet, &nr_node_list) {
489                 nr_node_lock(s);
490                 for (i = 0; i < s->count; i++) {
491                         switch (s->routes[i].obs_count) {
492                         case 0:         /* A locked entry */
493                                 break;
494
495                         case 1:         /* From 1 -> 0 */
496                                 nr_neigh = s->routes[i].neighbour;
497
498                                 nr_neigh->count--;
499                                 nr_neigh_put(nr_neigh);
500
501                                 if (nr_neigh->count == 0 && !nr_neigh->locked)
502                                         nr_remove_neigh(nr_neigh);
503
504                                 s->count--;
505
506                                 switch (i) {
507                                         case 0:
508                                                 s->routes[0] = s->routes[1];
509                                         case 1:
510                                                 s->routes[1] = s->routes[2];
511                                         case 2:
512                                                 break;
513                                 }
514                                 break;
515
516                         default:
517                                 s->routes[i].obs_count--;
518                                 break;
519
520                         }
521                 }
522
523                 if (s->count <= 0)
524                         nr_remove_node_locked(s);
525                 nr_node_unlock(s);
526         }
527         spin_unlock_bh(&nr_node_list_lock);
528
529         return 0;
530 }
531
532 /*
533  *      A device has been removed. Remove its routes and neighbours.
534  */
535 void nr_rt_device_down(struct net_device *dev)
536 {
537         struct nr_neigh *s;
538         struct hlist_node *node, *nodet, *node2, *node2t;
539         struct nr_node  *t;
540         int i;
541
542         spin_lock_bh(&nr_neigh_list_lock);
543         nr_neigh_for_each_safe(s, node, nodet, &nr_neigh_list) {
544                 if (s->dev == dev) {
545                         spin_lock_bh(&nr_node_list_lock);
546                         nr_node_for_each_safe(t, node2, node2t, &nr_node_list) {
547                                 nr_node_lock(t);
548                                 for (i = 0; i < t->count; i++) {
549                                         if (t->routes[i].neighbour == s) {
550                                                 t->count--;
551
552                                                 switch (i) {
553                                                 case 0:
554                                                         t->routes[0] = t->routes[1];
555                                                 case 1:
556                                                         t->routes[1] = t->routes[2];
557                                                 case 2:
558                                                         break;
559                                                 }
560                                         }
561                                 }
562
563                                 if (t->count <= 0)
564                                         nr_remove_node_locked(t);
565                                 nr_node_unlock(t);
566                         }
567                         spin_unlock_bh(&nr_node_list_lock);
568
569                         nr_remove_neigh_locked(s);
570                 }
571         }
572         spin_unlock_bh(&nr_neigh_list_lock);
573 }
574
575 /*
576  *      Check that the device given is a valid AX.25 interface that is "up".
577  *      Or a valid ethernet interface with an AX.25 callsign binding.
578  */
579 static struct net_device *nr_ax25_dev_get(char *devname)
580 {
581         struct net_device *dev;
582
583         if ((dev = dev_get_by_name(devname)) == NULL)
584                 return NULL;
585
586         if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
587                 return dev;
588
589         dev_put(dev);
590         return NULL;
591 }
592
593 /*
594  *      Find the first active NET/ROM device, usually "nr0".
595  */
596 struct net_device *nr_dev_first(void)
597 {
598         struct net_device *dev, *first = NULL;
599
600         read_lock(&dev_base_lock);
601         for (dev = dev_base; dev != NULL; dev = dev->next) {
602                 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM)
603                         if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
604                                 first = dev;
605         }
606         if (first)
607                 dev_hold(first);
608         read_unlock(&dev_base_lock);
609
610         return first;
611 }
612
613 /*
614  *      Find the NET/ROM device for the given callsign.
615  */
616 struct net_device *nr_dev_get(ax25_address *addr)
617 {
618         struct net_device *dev;
619
620         read_lock(&dev_base_lock);
621         for (dev = dev_base; dev != NULL; dev = dev->next) {
622                 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_NETROM && ax25cmp(addr, (ax25_address *)dev->dev_addr) == 0) {
623                         dev_hold(dev);
624                         goto out;
625                 }
626         }
627 out:
628         read_unlock(&dev_base_lock);
629         return dev;
630 }
631
632 static ax25_digi *nr_call_to_digi(int ndigis, ax25_address *digipeaters)
633 {
634         static ax25_digi ax25_digi;
635         int i;
636
637         if (ndigis == 0)
638                 return NULL;
639
640         for (i = 0; i < ndigis; i++) {
641                 ax25_digi.calls[i]    = digipeaters[i];
642                 ax25_digi.repeated[i] = 0;
643         }
644
645         ax25_digi.ndigi      = ndigis;
646         ax25_digi.lastrepeat = -1;
647
648         return &ax25_digi;
649 }
650
651 /*
652  *      Handle the ioctls that control the routing functions.
653  */
654 int nr_rt_ioctl(unsigned int cmd, void __user *arg)
655 {
656         struct nr_route_struct nr_route;
657         struct net_device *dev;
658         int ret;
659
660         switch (cmd) {
661         case SIOCADDRT:
662                 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
663                         return -EFAULT;
664                 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
665                         return -EINVAL;
666                 if (nr_route.ndigis < 0 || nr_route.ndigis > AX25_MAX_DIGIS) {
667                         dev_put(dev);
668                         return -EINVAL;
669                 }
670                 switch (nr_route.type) {
671                 case NETROM_NODE:
672                         ret = nr_add_node(&nr_route.callsign,
673                                 nr_route.mnemonic,
674                                 &nr_route.neighbour,
675                                 nr_call_to_digi(nr_route.ndigis, nr_route.digipeaters),
676                                 dev, nr_route.quality,
677                                 nr_route.obs_count);
678                         break;
679                 case NETROM_NEIGH:
680                         ret = nr_add_neigh(&nr_route.callsign,
681                                 nr_call_to_digi(nr_route.ndigis, nr_route.digipeaters),
682                                 dev, nr_route.quality);
683                         break;
684                 default:
685                         ret = -EINVAL;
686                 }
687                 dev_put(dev);
688                 return ret;
689
690         case SIOCDELRT:
691                 if (copy_from_user(&nr_route, arg, sizeof(struct nr_route_struct)))
692                         return -EFAULT;
693                 if ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
694                         return -EINVAL;
695                 switch (nr_route.type) {
696                 case NETROM_NODE:
697                         ret = nr_del_node(&nr_route.callsign,
698                                 &nr_route.neighbour, dev);
699                         break;
700                 case NETROM_NEIGH:
701                         ret = nr_del_neigh(&nr_route.callsign,
702                                 dev, nr_route.quality);
703                         break;
704                 default:
705                         ret = -EINVAL;
706                 }
707                 dev_put(dev);
708                 return ret;
709
710         case SIOCNRDECOBS:
711                 return nr_dec_obs();
712
713         default:
714                 return -EINVAL;
715         }
716
717         return 0;
718 }
719
720 /*
721  *      A level 2 link has timed out, therefore it appears to be a poor link,
722  *      then don't use that neighbour until it is reset.
723  */
724 void nr_link_failed(ax25_cb *ax25, int reason)
725 {
726         struct nr_neigh *s, *nr_neigh = NULL;
727         struct hlist_node *node;
728         struct nr_node  *nr_node = NULL;
729
730         spin_lock_bh(&nr_neigh_list_lock);
731         nr_neigh_for_each(s, node, &nr_neigh_list) {
732                 if (s->ax25 == ax25) {
733                         nr_neigh_hold(s);
734                         nr_neigh = s;
735                         break;
736                 }
737         }
738         spin_unlock_bh(&nr_neigh_list_lock);
739
740         if (nr_neigh == NULL)
741                 return;
742
743         nr_neigh->ax25 = NULL;
744         ax25_cb_put(ax25);
745
746         if (++nr_neigh->failed < sysctl_netrom_link_fails_count) {
747                 nr_neigh_put(nr_neigh);
748                 return;
749         }
750         spin_lock_bh(&nr_node_list_lock);
751         nr_node_for_each(nr_node, node, &nr_node_list) {
752                 nr_node_lock(nr_node);
753                 if (nr_node->which < nr_node->count &&
754                     nr_node->routes[nr_node->which].neighbour == nr_neigh)
755                         nr_node->which++;
756                 nr_node_unlock(nr_node);
757         }
758         spin_unlock_bh(&nr_node_list_lock);
759         nr_neigh_put(nr_neigh);
760 }
761
762 /*
763  *      Route a frame to an appropriate AX.25 connection. A NULL ax25_cb
764  *      indicates an internally generated frame.
765  */
766 int nr_route_frame(struct sk_buff *skb, ax25_cb *ax25)
767 {
768         ax25_address *nr_src, *nr_dest;
769         struct nr_neigh *nr_neigh;
770         struct nr_node  *nr_node;
771         struct net_device *dev;
772         unsigned char *dptr;
773         ax25_cb *ax25s;
774         int ret;
775         struct sk_buff *skbn;
776
777
778         nr_src  = (ax25_address *)(skb->data + 0);
779         nr_dest = (ax25_address *)(skb->data + 7);
780
781         if (ax25 != NULL) {
782                 ret = nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
783                                   ax25->ax25_dev->dev, 0,
784                                   sysctl_netrom_obsolescence_count_initialiser);
785                 if (ret)
786                         return ret;
787         }
788
789         if ((dev = nr_dev_get(nr_dest)) != NULL) {      /* Its for me */
790                 if (ax25 == NULL)                       /* Its from me */
791                         ret = nr_loopback_queue(skb);
792                 else
793                         ret = nr_rx_frame(skb, dev);
794                 dev_put(dev);
795                 return ret;
796         }
797
798         if (!sysctl_netrom_routing_control && ax25 != NULL)
799                 return 0;
800
801         /* Its Time-To-Live has expired */
802         if (skb->data[14] == 1) {
803                 return 0;
804         }
805
806         nr_node = nr_node_get(nr_dest);
807         if (nr_node == NULL)
808                 return 0;
809         nr_node_lock(nr_node);
810
811         if (nr_node->which >= nr_node->count) {
812                 nr_node_unlock(nr_node);
813                 nr_node_put(nr_node);
814                 return 0;
815         }
816
817         nr_neigh = nr_node->routes[nr_node->which].neighbour;
818
819         if ((dev = nr_dev_first()) == NULL) {
820                 nr_node_unlock(nr_node);
821                 nr_node_put(nr_node);
822                 return 0;
823         }
824
825         /* We are going to change the netrom headers so we should get our
826            own skb, we also did not know until now how much header space
827            we had to reserve... - RXQ */
828         if ((skbn=skb_copy_expand(skb, dev->hard_header_len, 0, GFP_ATOMIC)) == NULL) {
829                 nr_node_unlock(nr_node);
830                 nr_node_put(nr_node);
831                 dev_put(dev);
832                 return 0;
833         }
834         kfree_skb(skb);
835         skb=skbn;
836         skb->data[14]--;
837
838         dptr  = skb_push(skb, 1);
839         *dptr = AX25_P_NETROM;
840
841         ax25s = ax25_send_frame(skb, 256, (ax25_address *)dev->dev_addr, &nr_neigh->callsign, nr_neigh->digipeat, nr_neigh->dev);
842         if (nr_neigh->ax25 && ax25s) {
843                 /* We were already holding this ax25_cb */
844                 ax25_cb_put(ax25s);
845         }
846         nr_neigh->ax25 = ax25s;
847
848         dev_put(dev);
849         ret = (nr_neigh->ax25 != NULL);
850         nr_node_unlock(nr_node);
851         nr_node_put(nr_node);
852
853         return ret;
854 }
855
856 #ifdef CONFIG_PROC_FS
857
858 static void *nr_node_start(struct seq_file *seq, loff_t *pos)
859 {
860         struct nr_node *nr_node;
861         struct hlist_node *node;
862         int i = 1;
863
864         spin_lock_bh(&nr_node_list_lock);
865         if (*pos == 0)
866                 return SEQ_START_TOKEN;
867
868         nr_node_for_each(nr_node, node, &nr_node_list) {
869                 if (i == *pos)
870                         return nr_node;
871                 ++i;
872         }
873
874         return NULL;
875 }
876
877 static void *nr_node_next(struct seq_file *seq, void *v, loff_t *pos)
878 {
879         struct hlist_node *node;
880         ++*pos;
881
882         node = (v == SEQ_START_TOKEN)
883                 ? nr_node_list.first
884                 : ((struct nr_node *)v)->node_node.next;
885
886         return hlist_entry(node, struct nr_node, node_node);
887 }
888
889 static void nr_node_stop(struct seq_file *seq, void *v)
890 {
891         spin_unlock_bh(&nr_node_list_lock);
892 }
893
894 static int nr_node_show(struct seq_file *seq, void *v)
895 {
896         char buf[11];
897         int i;
898
899         if (v == SEQ_START_TOKEN)
900                 seq_puts(seq,
901                          "callsign  mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
902         else {
903                 struct nr_node *nr_node = v;
904                 nr_node_lock(nr_node);
905                 seq_printf(seq, "%-9s %-7s  %d %d",
906                         ax2asc(buf, &nr_node->callsign),
907                         (nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
908                         nr_node->which + 1,
909                         nr_node->count);
910
911                 for (i = 0; i < nr_node->count; i++) {
912                         seq_printf(seq, "  %3d   %d %05d",
913                                 nr_node->routes[i].quality,
914                                 nr_node->routes[i].obs_count,
915                                 nr_node->routes[i].neighbour->number);
916                 }
917                 nr_node_unlock(nr_node);
918
919                 seq_puts(seq, "\n");
920         }
921         return 0;
922 }
923
924 static struct seq_operations nr_node_seqops = {
925         .start = nr_node_start,
926         .next = nr_node_next,
927         .stop = nr_node_stop,
928         .show = nr_node_show,
929 };
930
931 static int nr_node_info_open(struct inode *inode, struct file *file)
932 {
933         return seq_open(file, &nr_node_seqops);
934 }
935
936 const struct file_operations nr_nodes_fops = {
937         .owner = THIS_MODULE,
938         .open = nr_node_info_open,
939         .read = seq_read,
940         .llseek = seq_lseek,
941         .release = seq_release,
942 };
943
944 static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
945 {
946         struct nr_neigh *nr_neigh;
947         struct hlist_node *node;
948         int i = 1;
949
950         spin_lock_bh(&nr_neigh_list_lock);
951         if (*pos == 0)
952                 return SEQ_START_TOKEN;
953
954         nr_neigh_for_each(nr_neigh, node, &nr_neigh_list) {
955                 if (i == *pos)
956                         return nr_neigh;
957         }
958         return NULL;
959 }
960
961 static void *nr_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
962 {
963         struct hlist_node *node;
964         ++*pos;
965
966         node = (v == SEQ_START_TOKEN)
967                 ? nr_neigh_list.first
968                 : ((struct nr_neigh *)v)->neigh_node.next;
969
970         return hlist_entry(node, struct nr_neigh, neigh_node);
971 }
972
973 static void nr_neigh_stop(struct seq_file *seq, void *v)
974 {
975         spin_unlock_bh(&nr_neigh_list_lock);
976 }
977
978 static int nr_neigh_show(struct seq_file *seq, void *v)
979 {
980         char buf[11];
981         int i;
982
983         if (v == SEQ_START_TOKEN)
984                 seq_puts(seq, "addr  callsign  dev  qual lock count failed digipeaters\n");
985         else {
986                 struct nr_neigh *nr_neigh = v;
987
988                 seq_printf(seq, "%05d %-9s %-4s  %3d    %d   %3d    %3d",
989                         nr_neigh->number,
990                         ax2asc(buf, &nr_neigh->callsign),
991                         nr_neigh->dev ? nr_neigh->dev->name : "???",
992                         nr_neigh->quality,
993                         nr_neigh->locked,
994                         nr_neigh->count,
995                         nr_neigh->failed);
996
997                 if (nr_neigh->digipeat != NULL) {
998                         for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
999                                 seq_printf(seq, " %s",
1000                                            ax2asc(buf, &nr_neigh->digipeat->calls[i]));
1001                 }
1002
1003                 seq_puts(seq, "\n");
1004         }
1005         return 0;
1006 }
1007
1008 static struct seq_operations nr_neigh_seqops = {
1009         .start = nr_neigh_start,
1010         .next = nr_neigh_next,
1011         .stop = nr_neigh_stop,
1012         .show = nr_neigh_show,
1013 };
1014
1015 static int nr_neigh_info_open(struct inode *inode, struct file *file)
1016 {
1017         return seq_open(file, &nr_neigh_seqops);
1018 }
1019
1020 const struct file_operations nr_neigh_fops = {
1021         .owner = THIS_MODULE,
1022         .open = nr_neigh_info_open,
1023         .read = seq_read,
1024         .llseek = seq_lseek,
1025         .release = seq_release,
1026 };
1027
1028 #endif
1029
1030 /*
1031  *      Free all memory associated with the nodes and routes lists.
1032  */
1033 void __exit nr_rt_free(void)
1034 {
1035         struct nr_neigh *s = NULL;
1036         struct nr_node  *t = NULL;
1037         struct hlist_node *node, *nodet;
1038
1039         spin_lock_bh(&nr_neigh_list_lock);
1040         spin_lock_bh(&nr_node_list_lock);
1041         nr_node_for_each_safe(t, node, nodet, &nr_node_list) {
1042                 nr_node_lock(t);
1043                 nr_remove_node_locked(t);
1044                 nr_node_unlock(t);
1045         }
1046         nr_neigh_for_each_safe(s, node, nodet, &nr_neigh_list) {
1047                 while(s->count) {
1048                         s->count--;
1049                         nr_neigh_put(s);
1050                 }
1051                 nr_remove_neigh_locked(s);
1052         }
1053         spin_unlock_bh(&nr_node_list_lock);
1054         spin_unlock_bh(&nr_neigh_list_lock);
1055 }