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