net/netrom/nr_route.c

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