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                 ret = nr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat,
 784                                   ax25->ax25_dev->dev, 0,
 785                                   sysctl_netrom_obsolescence_count_initialiser);
 786                 if (ret)
 787                         return ret;
 788         }
 789
 790         if ((dev = nr_dev_get(nr_dest)) != NULL) {      /* Its for me */
 791                 if (ax25 == NULL)                       /* Its from me */
 792                         ret = nr_loopback_queue(skb);
 793                 else
 794                         ret = nr_rx_frame(skb, dev);
 795                 dev_put(dev);
 796                 return ret;
 797         }
 798
 799         if (!sysctl_netrom_routing_control && ax25 != NULL)
 800                 return 0;
 801
 802         /* Its Time-To-Live has expired */
 803         if (skb->data[14] == 1) {
 804                 return 0;
 805         }
 806
 807         nr_node = nr_node_get(nr_dest);
 808         if (nr_node == NULL)
 809                 return 0;
 810         nr_node_lock(nr_node);
 811
 812         if (nr_node->which >= nr_node->count) {
 813                 nr_node_unlock(nr_node);
 814                 nr_node_put(nr_node);
 815                 return 0;
 816         }
 817
 818         nr_neigh = nr_node->routes[nr_node->which].neighbour;
 819
 820         if ((dev = nr_dev_first()) == NULL) {
 821                 nr_node_unlock(nr_node);
 822                 nr_node_put(nr_node);
 823                 return 0;
 824         }
 825
 826         /* We are going to change the netrom headers so we should get our
 827            own skb, we also did not know until now how much header space
 828            we had to reserve... - RXQ */
 829         if ((skbn=skb_copy_expand(skb, dev->hard_header_len, 0, GFP_ATOMIC)) == NULL) {
 830                 nr_node_unlock(nr_node);
 831                 nr_node_put(nr_node);
 832                 dev_put(dev);
 833                 return 0;
 834         }
 835         kfree_skb(skb);
 836         skb=skbn;
 837         skb->data[14]--;
 838
 839         dptr  = skb_push(skb, 1);
 840         *dptr = AX25_P_NETROM;
 841
 842         ax25s = ax25_send_frame(skb, 256, (ax25_address *)dev->dev_addr, &nr_neigh->callsign, nr_neigh->digipeat, nr_neigh->dev);
 843         if (nr_neigh->ax25 && ax25s) {
 844                 /* We were already holding this ax25_cb */
 845                 ax25_cb_put(ax25s);
 846         }
 847         nr_neigh->ax25 = ax25s;
 848
 849         dev_put(dev);
 850         ret = (nr_neigh->ax25 != NULL);
 851         nr_node_unlock(nr_node);
 852         nr_node_put(nr_node);
 853
 854         return ret;
 855 }
 856
 857 #ifdef CONFIG_PROC_FS
 858
 859 static void *nr_node_start(struct seq_file *seq, loff_t *pos)
 860 {
 861         struct nr_node *nr_node;
 862         struct hlist_node *node;
 863         int i = 1;
 864
 865         spin_lock_bh(&nr_node_list_lock);
 866         if (*pos == 0)
 867                 return SEQ_START_TOKEN;
 868
 869         nr_node_for_each(nr_node, node, &nr_node_list) {
 870                 if (i == *pos)
 871                         return nr_node;
 872                 ++i;
 873         }
 874
 875         return NULL;
 876 }
 877
 878 static void *nr_node_next(struct seq_file *seq, void *v, loff_t *pos)
 879 {
 880         struct hlist_node *node;
 881         ++*pos;
 882
 883         node = (v == SEQ_START_TOKEN)
 884                 ? nr_node_list.first
 885                 : ((struct nr_node *)v)->node_node.next;
 886
 887         return hlist_entry(node, struct nr_node, node_node);
 888 }
 889
 890 static void nr_node_stop(struct seq_file *seq, void *v)
 891 {
 892         spin_unlock_bh(&nr_node_list_lock);
 893 }
 894
 895 static int nr_node_show(struct seq_file *seq, void *v)
 896 {
 897         char buf[11];
 898         int i;
 899
 900         if (v == SEQ_START_TOKEN)
 901                 seq_puts(seq,
 902                          "callsign  mnemonic w n qual obs neigh qual obs neigh qual obs neigh\n");
 903         else {
 904                 struct nr_node *nr_node = v;
 905                 nr_node_lock(nr_node);
 906                 seq_printf(seq, "%-9s %-7s  %d %d",
 907                         ax2asc(buf, &nr_node->callsign),
 908                         (nr_node->mnemonic[0] == '\0') ? "*" : nr_node->mnemonic,
 909                         nr_node->which + 1,
 910                         nr_node->count);
 911
 912                 for (i = 0; i < nr_node->count; i++) {
 913                         seq_printf(seq, "  %3d   %d %05d",
 914                                 nr_node->routes[i].quality,
 915                                 nr_node->routes[i].obs_count,
 916                                 nr_node->routes[i].neighbour->number);
 917                 }
 918                 nr_node_unlock(nr_node);
 919
 920                 seq_puts(seq, "\n");
 921         }
 922         return 0;
 923 }
 924
 925 static struct seq_operations nr_node_seqops = {
 926         .start = nr_node_start,
 927         .next = nr_node_next,
 928         .stop = nr_node_stop,
 929         .show = nr_node_show,
 930 };
 931
 932 static int nr_node_info_open(struct inode *inode, struct file *file)
 933 {
 934         return seq_open(file, &nr_node_seqops);
 935 }
 936
 937 struct file_operations nr_nodes_fops = {
 938         .owner = THIS_MODULE,
 939         .open = nr_node_info_open,
 940         .read = seq_read,
 941         .llseek = seq_lseek,
 942         .release = seq_release,
 943 };
 944
 945 static void *nr_neigh_start(struct seq_file *seq, loff_t *pos)
 946 {
 947         struct nr_neigh *nr_neigh;
 948         struct hlist_node *node;
 949         int i = 1;
 950
 951         spin_lock_bh(&nr_neigh_list_lock);
 952         if (*pos == 0)
 953                 return SEQ_START_TOKEN;
 954
 955         nr_neigh_for_each(nr_neigh, node, &nr_neigh_list) {
 956                 if (i == *pos)
 957                         return nr_neigh;
 958         }
 959         return NULL;
 960 }
 961
 962 static void *nr_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
 963 {
 964         struct hlist_node *node;
 965         ++*pos;
 966
 967         node = (v == SEQ_START_TOKEN)
 968                 ? nr_neigh_list.first
 969                 : ((struct nr_neigh *)v)->neigh_node.next;
 970
 971         return hlist_entry(node, struct nr_neigh, neigh_node);
 972 }
 973
 974 static void nr_neigh_stop(struct seq_file *seq, void *v)
 975 {
 976         spin_unlock_bh(&nr_neigh_list_lock);
 977 }
 978
 979 static int nr_neigh_show(struct seq_file *seq, void *v)
 980 {
 981         char buf[11];
 982         int i;
 983
 984         if (v == SEQ_START_TOKEN)
 985                 seq_puts(seq, "addr  callsign  dev  qual lock count failed digipeaters\n");
 986         else {
 987                 struct nr_neigh *nr_neigh = v;
 988
 989                 seq_printf(seq, "%05d %-9s %-4s  %3d    %d   %3d    %3d",
 990                         nr_neigh->number,
 991                         ax2asc(buf, &nr_neigh->callsign),
 992                         nr_neigh->dev ? nr_neigh->dev->name : "???",
 993                         nr_neigh->quality,
 994                         nr_neigh->locked,
 995                         nr_neigh->count,
 996                         nr_neigh->failed);
 997
 998                 if (nr_neigh->digipeat != NULL) {
 999                         for (i = 0; i < nr_neigh->digipeat->ndigi; i++)
1000                                 seq_printf(seq, " %s",
1001                                            ax2asc(buf, &nr_neigh->digipeat->calls[i]));
1002                 }
1003
1004                 seq_puts(seq, "\n");
1005         }
1006         return 0;
1007 }
1008
1009 static struct seq_operations nr_neigh_seqops = {
1010         .start = nr_neigh_start,
1011         .next = nr_neigh_next,
1012         .stop = nr_neigh_stop,
1013         .show = nr_neigh_show,
1014 };
1015
1016 static int nr_neigh_info_open(struct inode *inode, struct file *file)
1017 {
1018         return seq_open(file, &nr_neigh_seqops);
1019 }
1020
1021 struct file_operations nr_neigh_fops = {
1022         .owner = THIS_MODULE,
1023         .open = nr_neigh_info_open,
1024         .read = seq_read,
1025         .llseek = seq_lseek,
1026         .release = seq_release,
1027 };
1028
1029 #endif
1030
1031 /*
1032  *      Free all memory associated with the nodes and routes lists.
1033  */
1034 void __exit nr_rt_free(void)
1035 {
1036         struct nr_neigh *s = NULL;
1037         struct nr_node  *t = NULL;
1038         struct hlist_node *node, *nodet;
1039
1040         spin_lock_bh(&nr_neigh_list_lock);
1041         spin_lock_bh(&nr_node_list_lock);
1042         nr_node_for_each_safe(t, node, nodet, &nr_node_list) {
1043                 nr_node_lock(t);
1044                 nr_remove_node_locked(t);
1045                 nr_node_unlock(t);
1046         }
1047         nr_neigh_for_each_safe(s, node, nodet, &nr_neigh_list) {
1048                 while(s->count) {
1049                         s->count--;
1050                         nr_neigh_put(s);
1051                 }
1052                 nr_remove_neigh_locked(s);
1053         }
1054         spin_unlock_bh(&nr_node_list_lock);
1055         spin_unlock_bh(&nr_neigh_list_lock);
1056 }