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