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