net/netrom/nr_route.c

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