git.oblomov.eu Git - linux-2.6/blob - 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 }