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