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