net/netrom/nr_route.c

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