net/rose/rose_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 (C) Jonathan Naylor G4KLX ([email protected])
   8  * Copyright (C) Terry Dawson VK2KTJ ([email protected])
   9  */
  10 #include <linux/errno.h>
  11 #include <linux/types.h>
  12 #include <linux/socket.h>
  13 #include <linux/in.h>
  14 #include <linux/kernel.h>
  15 #include <linux/sched.h>
  16 #include <linux/timer.h>
  17 #include <linux/string.h>
  18 #include <linux/sockios.h>
  19 #include <linux/net.h>
  20 #include <net/ax25.h>
  21 #include <linux/inet.h>
  22 #include <linux/netdevice.h>
  23 #include <net/arp.h>
  24 #include <linux/if_arp.h>
  25 #include <linux/skbuff.h>
  26 #include <net/sock.h>
  27 #include <net/tcp_states.h>
  28 #include <asm/system.h>
  29 #include <asm/uaccess.h>
  30 #include <linux/fcntl.h>
  31 #include <linux/termios.h>      /* For TIOCINQ/OUTQ */
  32 #include <linux/mm.h>
  33 #include <linux/interrupt.h>
  34 #include <linux/notifier.h>
  35 #include <linux/netfilter.h>
  36 #include <linux/init.h>
  37 #include <net/rose.h>
  38 #include <linux/seq_file.h>
  39
  40 static unsigned int rose_neigh_no = 1;
  41
  42 static struct rose_node  *rose_node_list;
  43 static DEFINE_SPINLOCK(rose_node_list_lock);
  44 static struct rose_neigh *rose_neigh_list;
  45 static DEFINE_SPINLOCK(rose_neigh_list_lock);
  46 static struct rose_route *rose_route_list;
  47 static DEFINE_SPINLOCK(rose_route_list_lock);
  48
  49 struct rose_neigh *rose_loopback_neigh;
  50
  51 /*
  52  *      Add a new route to a node, and in the process add the node and the
  53  *      neighbour if it is new.
  54  */
  55 static int rose_add_node(struct rose_route_struct *rose_route,
  56         struct net_device *dev)
  57 {
  58         struct rose_node  *rose_node, *rose_tmpn, *rose_tmpp;
  59         struct rose_neigh *rose_neigh;
  60         int i, res = 0;
  61
  62         spin_lock_bh(&rose_node_list_lock);
  63         spin_lock_bh(&rose_neigh_list_lock);
  64
  65         rose_node = rose_node_list;
  66         while (rose_node != NULL) {
  67                 if ((rose_node->mask == rose_route->mask) &&
  68                     (rosecmpm(&rose_route->address, &rose_node->address,
  69                               rose_route->mask) == 0))
  70                         break;
  71                 rose_node = rose_node->next;
  72         }
  73
  74         if (rose_node != NULL && rose_node->loopback) {
  75                 res = -EINVAL;
  76                 goto out;
  77         }
  78
  79         rose_neigh = rose_neigh_list;
  80         while (rose_neigh != NULL) {
  81                 if (ax25cmp(&rose_route->neighbour, &rose_neigh->callsign) == 0
  82                     && rose_neigh->dev == dev)
  83                         break;
  84                 rose_neigh = rose_neigh->next;
  85         }
  86
  87         if (rose_neigh == NULL) {
  88                 rose_neigh = kmalloc(sizeof(*rose_neigh), GFP_ATOMIC);
  89                 if (rose_neigh == NULL) {
  90                         res = -ENOMEM;
  91                         goto out;
  92                 }
  93
  94                 rose_neigh->callsign  = rose_route->neighbour;
  95                 rose_neigh->digipeat  = NULL;
  96                 rose_neigh->ax25      = NULL;
  97                 rose_neigh->dev       = dev;
  98                 rose_neigh->count     = 0;
  99                 rose_neigh->use       = 0;
 100                 rose_neigh->dce_mode  = 0;
 101                 rose_neigh->loopback  = 0;
 102                 rose_neigh->number    = rose_neigh_no++;
 103                 rose_neigh->restarted = 0;
 104
 105                 skb_queue_head_init(&rose_neigh->queue);
 106
 107                 init_timer(&rose_neigh->ftimer);
 108                 init_timer(&rose_neigh->t0timer);
 109
 110                 if (rose_route->ndigis != 0) {
 111                         if ((rose_neigh->digipeat = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
 112                                 kfree(rose_neigh);
 113                                 res = -ENOMEM;
 114                                 goto out;
 115                         }
 116
 117                         rose_neigh->digipeat->ndigi      = rose_route->ndigis;
 118                         rose_neigh->digipeat->lastrepeat = -1;
 119
 120                         for (i = 0; i < rose_route->ndigis; i++) {
 121                                 rose_neigh->digipeat->calls[i]    =
 122                                         rose_route->digipeaters[i];
 123                                 rose_neigh->digipeat->repeated[i] = 0;
 124                         }
 125                 }
 126
 127                 rose_neigh->next = rose_neigh_list;
 128                 rose_neigh_list  = rose_neigh;
 129         }
 130
 131         /*
 132          * This is a new node to be inserted into the list. Find where it needs
 133          * to be inserted into the list, and insert it. We want to be sure
 134          * to order the list in descending order of mask size to ensure that
 135          * later when we are searching this list the first match will be the
 136          * best match.
 137          */
 138         if (rose_node == NULL) {
 139                 rose_tmpn = rose_node_list;
 140                 rose_tmpp = NULL;
 141
 142                 while (rose_tmpn != NULL) {
 143                         if (rose_tmpn->mask > rose_route->mask) {
 144                                 rose_tmpp = rose_tmpn;
 145                                 rose_tmpn = rose_tmpn->next;
 146                         } else {
 147                                 break;
 148                         }
 149                 }
 150
 151                 /* create new node */
 152                 rose_node = kmalloc(sizeof(*rose_node), GFP_ATOMIC);
 153                 if (rose_node == NULL) {
 154                         res = -ENOMEM;
 155                         goto out;
 156                 }
 157
 158                 rose_node->address      = rose_route->address;
 159                 rose_node->mask         = rose_route->mask;
 160                 rose_node->count        = 1;
 161                 rose_node->loopback     = 0;
 162                 rose_node->neighbour[0] = rose_neigh;
 163
 164                 if (rose_tmpn == NULL) {
 165                         if (rose_tmpp == NULL) {        /* Empty list */
 166                                 rose_node_list  = rose_node;
 167                                 rose_node->next = NULL;
 168                         } else {
 169                                 rose_tmpp->next = rose_node;
 170                                 rose_node->next = NULL;
 171                         }
 172                 } else {
 173                         if (rose_tmpp == NULL) {        /* 1st node */
 174                                 rose_node->next = rose_node_list;
 175                                 rose_node_list  = rose_node;
 176                         } else {
 177                                 rose_tmpp->next = rose_node;
 178                                 rose_node->next = rose_tmpn;
 179                         }
 180                 }
 181                 rose_neigh->count++;
 182
 183                 goto out;
 184         }
 185
 186         /* We have space, slot it in */
 187         if (rose_node->count < 3) {
 188                 rose_node->neighbour[rose_node->count] = rose_neigh;
 189                 rose_node->count++;
 190                 rose_neigh->count++;
 191         }
 192
 193 out:
 194         spin_unlock_bh(&rose_neigh_list_lock);
 195         spin_unlock_bh(&rose_node_list_lock);
 196
 197         return res;
 198 }
 199
 200 /*
 201  * Caller is holding rose_node_list_lock.
 202  */
 203 static void rose_remove_node(struct rose_node *rose_node)
 204 {
 205         struct rose_node *s;
 206
 207         if ((s = rose_node_list) == rose_node) {
 208                 rose_node_list = rose_node->next;
 209                 kfree(rose_node);
 210                 return;
 211         }
 212
 213         while (s != NULL && s->next != NULL) {
 214                 if (s->next == rose_node) {
 215                         s->next = rose_node->next;
 216                         kfree(rose_node);
 217                         return;
 218                 }
 219
 220                 s = s->next;
 221         }
 222 }
 223
 224 /*
 225  * Caller is holding rose_neigh_list_lock.
 226  */
 227 static void rose_remove_neigh(struct rose_neigh *rose_neigh)
 228 {
 229         struct rose_neigh *s;
 230
 231         rose_stop_ftimer(rose_neigh);
 232         rose_stop_t0timer(rose_neigh);
 233
 234         skb_queue_purge(&rose_neigh->queue);
 235
 236         spin_lock_bh(&rose_neigh_list_lock);
 237
 238         if ((s = rose_neigh_list) == rose_neigh) {
 239                 rose_neigh_list = rose_neigh->next;
 240                 spin_unlock_bh(&rose_neigh_list_lock);
 241                 kfree(rose_neigh->digipeat);
 242                 kfree(rose_neigh);
 243                 return;
 244         }
 245
 246         while (s != NULL && s->next != NULL) {
 247                 if (s->next == rose_neigh) {
 248                         s->next = rose_neigh->next;
 249                         spin_unlock_bh(&rose_neigh_list_lock);
 250                         kfree(rose_neigh->digipeat);
 251                         kfree(rose_neigh);
 252                         return;
 253                 }
 254
 255                 s = s->next;
 256         }
 257         spin_unlock_bh(&rose_neigh_list_lock);
 258 }
 259
 260 /*
 261  * Caller is holding rose_route_list_lock.
 262  */
 263 static void rose_remove_route(struct rose_route *rose_route)
 264 {
 265         struct rose_route *s;
 266
 267         if (rose_route->neigh1 != NULL)
 268                 rose_route->neigh1->use--;
 269
 270         if (rose_route->neigh2 != NULL)
 271                 rose_route->neigh2->use--;
 272
 273         if ((s = rose_route_list) == rose_route) {
 274                 rose_route_list = rose_route->next;
 275                 kfree(rose_route);
 276                 return;
 277         }
 278
 279         while (s != NULL && s->next != NULL) {
 280                 if (s->next == rose_route) {
 281                         s->next = rose_route->next;
 282                         kfree(rose_route);
 283                         return;
 284                 }
 285
 286                 s = s->next;
 287         }
 288 }
 289
 290 /*
 291  *      "Delete" a node. Strictly speaking remove a route to a node. The node
 292  *      is only deleted if no routes are left to it.
 293  */
 294 static int rose_del_node(struct rose_route_struct *rose_route,
 295         struct net_device *dev)
 296 {
 297         struct rose_node  *rose_node;
 298         struct rose_neigh *rose_neigh;
 299         int i, err = 0;
 300
 301         spin_lock_bh(&rose_node_list_lock);
 302         spin_lock_bh(&rose_neigh_list_lock);
 303
 304         rose_node = rose_node_list;
 305         while (rose_node != NULL) {
 306                 if ((rose_node->mask == rose_route->mask) &&
 307                     (rosecmpm(&rose_route->address, &rose_node->address,
 308                               rose_route->mask) == 0))
 309                         break;
 310                 rose_node = rose_node->next;
 311         }
 312
 313         if (rose_node == NULL || rose_node->loopback) {
 314                 err = -EINVAL;
 315                 goto out;
 316         }
 317
 318         rose_neigh = rose_neigh_list;
 319         while (rose_neigh != NULL) {
 320                 if (ax25cmp(&rose_route->neighbour, &rose_neigh->callsign) == 0
 321                     && rose_neigh->dev == dev)
 322                         break;
 323                 rose_neigh = rose_neigh->next;
 324         }
 325
 326         if (rose_neigh == NULL) {
 327                 err = -EINVAL;
 328                 goto out;
 329         }
 330
 331         for (i = 0; i < rose_node->count; i++) {
 332                 if (rose_node->neighbour[i] == rose_neigh) {
 333                         rose_neigh->count--;
 334
 335                         if (rose_neigh->count == 0 && rose_neigh->use == 0)
 336                                 rose_remove_neigh(rose_neigh);
 337
 338                         rose_node->count--;
 339
 340                         if (rose_node->count == 0) {
 341                                 rose_remove_node(rose_node);
 342                         } else {
 343                                 switch (i) {
 344                                 case 0:
 345                                         rose_node->neighbour[0] =
 346                                                 rose_node->neighbour[1];
 347                                 case 1:
 348                                         rose_node->neighbour[1] =
 349                                                 rose_node->neighbour[2];
 350                                 case 2:
 351                                         break;
 352                                 }
 353                         }
 354                         goto out;
 355                 }
 356         }
 357         err = -EINVAL;
 358
 359 out:
 360         spin_unlock_bh(&rose_neigh_list_lock);
 361         spin_unlock_bh(&rose_node_list_lock);
 362
 363         return err;
 364 }
 365
 366 /*
 367  *      Add the loopback neighbour.
 368  */
 369 int rose_add_loopback_neigh(void)
 370 {
 371         if ((rose_loopback_neigh = kmalloc(sizeof(struct rose_neigh), GFP_ATOMIC)) == NULL)
 372                 return -ENOMEM;
 373
 374         rose_loopback_neigh->callsign  = null_ax25_address;
 375         rose_loopback_neigh->digipeat  = NULL;
 376         rose_loopback_neigh->ax25      = NULL;
 377         rose_loopback_neigh->dev       = NULL;
 378         rose_loopback_neigh->count     = 0;
 379         rose_loopback_neigh->use       = 0;
 380         rose_loopback_neigh->dce_mode  = 1;
 381         rose_loopback_neigh->loopback  = 1;
 382         rose_loopback_neigh->number    = rose_neigh_no++;
 383         rose_loopback_neigh->restarted = 1;
 384
 385         skb_queue_head_init(&rose_loopback_neigh->queue);
 386
 387         init_timer(&rose_loopback_neigh->ftimer);
 388         init_timer(&rose_loopback_neigh->t0timer);
 389
 390         spin_lock_bh(&rose_neigh_list_lock);
 391         rose_loopback_neigh->next = rose_neigh_list;
 392         rose_neigh_list           = rose_loopback_neigh;
 393         spin_unlock_bh(&rose_neigh_list_lock);
 394
 395         return 0;
 396 }
 397
 398 /*
 399  *      Add a loopback node.
 400  */
 401 int rose_add_loopback_node(rose_address *address)
 402 {
 403         struct rose_node *rose_node;
 404         unsigned int err = 0;
 405
 406         spin_lock_bh(&rose_node_list_lock);
 407
 408         rose_node = rose_node_list;
 409         while (rose_node != NULL) {
 410                 if ((rose_node->mask == 10) &&
 411                      (rosecmpm(address, &rose_node->address, 10) == 0) &&
 412                      rose_node->loopback)
 413                         break;
 414                 rose_node = rose_node->next;
 415         }
 416
 417         if (rose_node != NULL)
 418                 goto out;
 419
 420         if ((rose_node = kmalloc(sizeof(*rose_node), GFP_ATOMIC)) == NULL) {
 421                 err = -ENOMEM;
 422                 goto out;
 423         }
 424
 425         rose_node->address      = *address;
 426         rose_node->mask         = 10;
 427         rose_node->count        = 1;
 428         rose_node->loopback     = 1;
 429         rose_node->neighbour[0] = rose_loopback_neigh;
 430
 431         /* Insert at the head of list. Address is always mask=10 */
 432         rose_node->next = rose_node_list;
 433         rose_node_list  = rose_node;
 434
 435         rose_loopback_neigh->count++;
 436
 437 out:
 438         spin_unlock_bh(&rose_node_list_lock);
 439
 440         return 0;
 441 }
 442
 443 /*
 444  *      Delete a loopback node.
 445  */
 446 void rose_del_loopback_node(rose_address *address)
 447 {
 448         struct rose_node *rose_node;
 449
 450         spin_lock_bh(&rose_node_list_lock);
 451
 452         rose_node = rose_node_list;
 453         while (rose_node != NULL) {
 454                 if ((rose_node->mask == 10) &&
 455                     (rosecmpm(address, &rose_node->address, 10) == 0) &&
 456                     rose_node->loopback)
 457                         break;
 458                 rose_node = rose_node->next;
 459         }
 460
 461         if (rose_node == NULL)
 462                 goto out;
 463
 464         rose_remove_node(rose_node);
 465
 466         rose_loopback_neigh->count--;
 467
 468 out:
 469         spin_unlock_bh(&rose_node_list_lock);
 470 }
 471
 472 /*
 473  *      A device has been removed. Remove its routes and neighbours.
 474  */
 475 void rose_rt_device_down(struct net_device *dev)
 476 {
 477         struct rose_neigh *s, *rose_neigh;
 478         struct rose_node  *t, *rose_node;
 479         int i;
 480
 481         spin_lock_bh(&rose_node_list_lock);
 482         spin_lock_bh(&rose_neigh_list_lock);
 483         rose_neigh = rose_neigh_list;
 484         while (rose_neigh != NULL) {
 485                 s          = rose_neigh;
 486                 rose_neigh = rose_neigh->next;
 487
 488                 if (s->dev != dev)
 489                         continue;
 490
 491                 rose_node = rose_node_list;
 492
 493                 while (rose_node != NULL) {
 494                         t         = rose_node;
 495                         rose_node = rose_node->next;
 496
 497                         for (i = 0; i < t->count; i++) {
 498                                 if (t->neighbour[i] != s)
 499                                         continue;
 500
 501                                 t->count--;
 502
 503                                 switch (i) {
 504                                 case 0:
 505                                         t->neighbour[0] = t->neighbour[1];
 506                                 case 1:
 507                                         t->neighbour[1] = t->neighbour[2];
 508                                 case 2:
 509                                         break;
 510                                 }
 511                         }
 512
 513                         if (t->count <= 0)
 514                                 rose_remove_node(t);
 515                 }
 516
 517                 rose_remove_neigh(s);
 518         }
 519         spin_unlock_bh(&rose_neigh_list_lock);
 520         spin_unlock_bh(&rose_node_list_lock);
 521 }
 522
 523 #if 0 /* Currently unused */
 524 /*
 525  *      A device has been removed. Remove its links.
 526  */
 527 void rose_route_device_down(struct net_device *dev)
 528 {
 529         struct rose_route *s, *rose_route;
 530
 531         spin_lock_bh(&rose_route_list_lock);
 532         rose_route = rose_route_list;
 533         while (rose_route != NULL) {
 534                 s          = rose_route;
 535                 rose_route = rose_route->next;
 536
 537                 if (s->neigh1->dev == dev || s->neigh2->dev == dev)
 538                         rose_remove_route(s);
 539         }
 540         spin_unlock_bh(&rose_route_list_lock);
 541 }
 542 #endif
 543
 544 /*
 545  *      Clear all nodes and neighbours out, except for neighbours with
 546  *      active connections going through them.
 547  *  Do not clear loopback neighbour and nodes.
 548  */
 549 static int rose_clear_routes(void)
 550 {
 551         struct rose_neigh *s, *rose_neigh;
 552         struct rose_node  *t, *rose_node;
 553
 554         spin_lock_bh(&rose_node_list_lock);
 555         spin_lock_bh(&rose_neigh_list_lock);
 556
 557         rose_neigh = rose_neigh_list;
 558         rose_node  = rose_node_list;
 559
 560         while (rose_node != NULL) {
 561                 t         = rose_node;
 562                 rose_node = rose_node->next;
 563                 if (!t->loopback)
 564                         rose_remove_node(t);
 565         }
 566
 567         while (rose_neigh != NULL) {
 568                 s          = rose_neigh;
 569                 rose_neigh = rose_neigh->next;
 570
 571                 if (s->use == 0 && !s->loopback) {
 572                         s->count = 0;
 573                         rose_remove_neigh(s);
 574                 }
 575         }
 576
 577         spin_unlock_bh(&rose_neigh_list_lock);
 578         spin_unlock_bh(&rose_node_list_lock);
 579
 580         return 0;
 581 }
 582
 583 /*
 584  *      Check that the device given is a valid AX.25 interface that is "up".
 585  */
 586 static struct net_device *rose_ax25_dev_get(char *devname)
 587 {
 588         struct net_device *dev;
 589
 590         if ((dev = dev_get_by_name(devname)) == NULL)
 591                 return NULL;
 592
 593         if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
 594                 return dev;
 595
 596         dev_put(dev);
 597         return NULL;
 598 }
 599
 600 /*
 601  *      Find the first active ROSE device, usually "rose0".
 602  */
 603 struct net_device *rose_dev_first(void)
 604 {
 605         struct net_device *dev, *first = NULL;
 606
 607         read_lock(&dev_base_lock);
 608         for (dev = dev_base; dev != NULL; dev = dev->next) {
 609                 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE)
 610                         if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
 611                                 first = dev;
 612         }
 613         read_unlock(&dev_base_lock);
 614
 615         return first;
 616 }
 617
 618 /*
 619  *      Find the ROSE device for the given address.
 620  */
 621 struct net_device *rose_dev_get(rose_address *addr)
 622 {
 623         struct net_device *dev;
 624
 625         read_lock(&dev_base_lock);
 626         for (dev = dev_base; dev != NULL; dev = dev->next) {
 627                 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE && rosecmp(addr, (rose_address *)dev->dev_addr) == 0) {
 628                         dev_hold(dev);
 629                         goto out;
 630                 }
 631         }
 632 out:
 633         read_unlock(&dev_base_lock);
 634         return dev;
 635 }
 636
 637 static int rose_dev_exists(rose_address *addr)
 638 {
 639         struct net_device *dev;
 640
 641         read_lock(&dev_base_lock);
 642         for (dev = dev_base; dev != NULL; dev = dev->next) {
 643                 if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE && rosecmp(addr, (rose_address *)dev->dev_addr) == 0)
 644                         goto out;
 645         }
 646 out:
 647         read_unlock(&dev_base_lock);
 648         return dev != NULL;
 649 }
 650
 651
 652
 653
 654 struct rose_route *rose_route_free_lci(unsigned int lci, struct rose_neigh *neigh)
 655 {
 656         struct rose_route *rose_route;
 657
 658         for (rose_route = rose_route_list; rose_route != NULL; rose_route = rose_route->next)
 659                 if ((rose_route->neigh1 == neigh && rose_route->lci1 == lci) ||
 660                     (rose_route->neigh2 == neigh && rose_route->lci2 == lci))
 661                         return rose_route;
 662
 663         return NULL;
 664 }
 665
 666 /*
 667  *      Find a neighbour given a ROSE address.
 668  */
 669 struct rose_neigh *rose_get_neigh(rose_address *addr, unsigned char *cause,
 670         unsigned char *diagnostic)
 671 {
 672         struct rose_neigh *res = NULL;
 673         struct rose_node *node;
 674         int failed = 0;
 675         int i;
 676
 677         spin_lock_bh(&rose_node_list_lock);
 678         for (node = rose_node_list; node != NULL; node = node->next) {
 679                 if (rosecmpm(addr, &node->address, node->mask) == 0) {
 680                         for (i = 0; i < node->count; i++) {
 681                                 if (!rose_ftimer_running(node->neighbour[i])) {
 682                                         res = node->neighbour[i];
 683                                         goto out;
 684                                 } else
 685                                         failed = 1;
 686                         }
 687                         break;
 688                 }
 689         }
 690
 691         if (failed) {
 692                 *cause      = ROSE_OUT_OF_ORDER;
 693                 *diagnostic = 0;
 694         } else {
 695                 *cause      = ROSE_NOT_OBTAINABLE;
 696                 *diagnostic = 0;
 697         }
 698
 699 out:
 700         spin_unlock_bh(&rose_node_list_lock);
 701
 702         return res;
 703 }
 704
 705 /*
 706  *      Handle the ioctls that control the routing functions.
 707  */
 708 int rose_rt_ioctl(unsigned int cmd, void __user *arg)
 709 {
 710         struct rose_route_struct rose_route;
 711         struct net_device *dev;
 712         int err;
 713
 714         switch (cmd) {
 715         case SIOCADDRT:
 716                 if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
 717                         return -EFAULT;
 718                 if ((dev = rose_ax25_dev_get(rose_route.device)) == NULL)
 719                         return -EINVAL;
 720                 if (rose_dev_exists(&rose_route.address)) { /* Can't add routes to ourself */
 721                         dev_put(dev);
 722                         return -EINVAL;
 723                 }
 724                 if (rose_route.mask > 10) /* Mask can't be more than 10 digits */
 725                         return -EINVAL;
 726                 if (rose_route.ndigis > AX25_MAX_DIGIS)
 727                         return -EINVAL;
 728                 err = rose_add_node(&rose_route, dev);
 729                 dev_put(dev);
 730                 return err;
 731
 732         case SIOCDELRT:
 733                 if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
 734                         return -EFAULT;
 735                 if ((dev = rose_ax25_dev_get(rose_route.device)) == NULL)
 736                         return -EINVAL;
 737                 err = rose_del_node(&rose_route, dev);
 738                 dev_put(dev);
 739                 return err;
 740
 741         case SIOCRSCLRRT:
 742                 return rose_clear_routes();
 743
 744         default:
 745                 return -EINVAL;
 746         }
 747
 748         return 0;
 749 }
 750
 751 static void rose_del_route_by_neigh(struct rose_neigh *rose_neigh)
 752 {
 753         struct rose_route *rose_route, *s;
 754
 755         rose_neigh->restarted = 0;
 756
 757         rose_stop_t0timer(rose_neigh);
 758         rose_start_ftimer(rose_neigh);
 759
 760         skb_queue_purge(&rose_neigh->queue);
 761
 762         spin_lock_bh(&rose_route_list_lock);
 763
 764         rose_route = rose_route_list;
 765
 766         while (rose_route != NULL) {
 767                 if ((rose_route->neigh1 == rose_neigh && rose_route->neigh2 == rose_neigh) ||
 768                     (rose_route->neigh1 == rose_neigh && rose_route->neigh2 == NULL)       ||
 769                     (rose_route->neigh2 == rose_neigh && rose_route->neigh1 == NULL)) {
 770                         s = rose_route->next;
 771                         rose_remove_route(rose_route);
 772                         rose_route = s;
 773                         continue;
 774                 }
 775
 776                 if (rose_route->neigh1 == rose_neigh) {
 777                         rose_route->neigh1->use--;
 778                         rose_route->neigh1 = NULL;
 779                         rose_transmit_clear_request(rose_route->neigh2, rose_route->lci2, ROSE_OUT_OF_ORDER, 0);
 780                 }
 781
 782                 if (rose_route->neigh2 == rose_neigh) {
 783                         rose_route->neigh2->use--;
 784                         rose_route->neigh2 = NULL;
 785                         rose_transmit_clear_request(rose_route->neigh1, rose_route->lci1, ROSE_OUT_OF_ORDER, 0);
 786                 }
 787
 788                 rose_route = rose_route->next;
 789         }
 790         spin_unlock_bh(&rose_route_list_lock);
 791 }
 792
 793 /*
 794  *      A level 2 link has timed out, therefore it appears to be a poor link,
 795  *      then don't use that neighbour until it is reset. Blow away all through
 796  *      routes and connections using this route.
 797  */
 798 void rose_link_failed(ax25_cb *ax25, int reason)
 799 {
 800         struct rose_neigh *rose_neigh;
 801
 802         spin_lock_bh(&rose_neigh_list_lock);
 803         rose_neigh = rose_neigh_list;
 804         while (rose_neigh != NULL) {
 805                 if (rose_neigh->ax25 == ax25)
 806                         break;
 807                 rose_neigh = rose_neigh->next;
 808         }
 809
 810         if (rose_neigh != NULL) {
 811                 rose_neigh->ax25 = NULL;
 812
 813                 rose_del_route_by_neigh(rose_neigh);
 814                 rose_kill_by_neigh(rose_neigh);
 815         }
 816         spin_unlock_bh(&rose_neigh_list_lock);
 817 }
 818
 819 /*
 820  *      A device has been "downed" remove its link status. Blow away all
 821  *      through routes and connections that use this device.
 822  */
 823 void rose_link_device_down(struct net_device *dev)
 824 {
 825         struct rose_neigh *rose_neigh;
 826
 827         for (rose_neigh = rose_neigh_list; rose_neigh != NULL; rose_neigh = rose_neigh->next) {
 828                 if (rose_neigh->dev == dev) {
 829                         rose_del_route_by_neigh(rose_neigh);
 830                         rose_kill_by_neigh(rose_neigh);
 831                 }
 832         }
 833 }
 834
 835 /*
 836  *      Route a frame to an appropriate AX.25 connection.
 837  */
 838 int rose_route_frame(struct sk_buff *skb, ax25_cb *ax25)
 839 {
 840         struct rose_neigh *rose_neigh, *new_neigh;
 841         struct rose_route *rose_route;
 842         struct rose_facilities_struct facilities;
 843         rose_address *src_addr, *dest_addr;
 844         struct sock *sk;
 845         unsigned short frametype;
 846         unsigned int lci, new_lci;
 847         unsigned char cause, diagnostic;
 848         struct net_device *dev;
 849         int len, res = 0;
 850         char buf[11];
 851
 852 #if 0
 853         if (call_in_firewall(PF_ROSE, skb->dev, skb->data, NULL, &skb) != FW_ACCEPT)
 854                 return res;
 855 #endif
 856
 857         frametype = skb->data[2];
 858         lci = ((skb->data[0] << 8) & 0xF00) + ((skb->data[1] << 0) & 0x0FF);
 859         src_addr  = (rose_address *)(skb->data + 9);
 860         dest_addr = (rose_address *)(skb->data + 4);
 861
 862         spin_lock_bh(&rose_node_list_lock);
 863         spin_lock_bh(&rose_neigh_list_lock);
 864         spin_lock_bh(&rose_route_list_lock);
 865
 866         rose_neigh = rose_neigh_list;
 867         while (rose_neigh != NULL) {
 868                 if (ax25cmp(&ax25->dest_addr, &rose_neigh->callsign) == 0 &&
 869                     ax25->ax25_dev->dev == rose_neigh->dev)
 870                         break;
 871                 rose_neigh = rose_neigh->next;
 872         }
 873
 874         if (rose_neigh == NULL) {
 875                 printk("rose_route : unknown neighbour or device %s\n",
 876                        ax2asc(buf, &ax25->dest_addr));
 877                 goto out;
 878         }
 879
 880         /*
 881          *      Obviously the link is working, halt the ftimer.
 882          */
 883         rose_stop_ftimer(rose_neigh);
 884
 885         /*
 886          *      LCI of zero is always for us, and its always a restart
 887          *      frame.
 888          */
 889         if (lci == 0) {
 890                 rose_link_rx_restart(skb, rose_neigh, frametype);
 891                 goto out;
 892         }
 893
 894         /*
 895          *      Find an existing socket.
 896          */
 897         if ((sk = rose_find_socket(lci, rose_neigh)) != NULL) {
 898                 if (frametype == ROSE_CALL_REQUEST) {
 899                         struct rose_sock *rose = rose_sk(sk);
 900
 901                         /* Remove an existing unused socket */
 902                         rose_clear_queues(sk);
 903                         rose->cause      = ROSE_NETWORK_CONGESTION;
 904                         rose->diagnostic = 0;
 905                         rose->neighbour->use--;
 906                         rose->neighbour  = NULL;
 907                         rose->lci        = 0;
 908                         rose->state      = ROSE_STATE_0;
 909                         sk->sk_state     = TCP_CLOSE;
 910                         sk->sk_err       = 0;
 911                         sk->sk_shutdown  |= SEND_SHUTDOWN;
 912                         if (!sock_flag(sk, SOCK_DEAD)) {
 913                                 sk->sk_state_change(sk);
 914                                 sock_set_flag(sk, SOCK_DEAD);
 915                         }
 916                 }
 917                 else {
 918                         skb->h.raw = skb->data;
 919                         res = rose_process_rx_frame(sk, skb);
 920                         goto out;
 921                 }
 922         }
 923
 924         /*
 925          *      Is is a Call Request and is it for us ?
 926          */
 927         if (frametype == ROSE_CALL_REQUEST)
 928                 if ((dev = rose_dev_get(dest_addr)) != NULL) {
 929                         res = rose_rx_call_request(skb, dev, rose_neigh, lci);
 930                         dev_put(dev);
 931                         goto out;
 932                 }
 933
 934         if (!sysctl_rose_routing_control) {
 935                 rose_transmit_clear_request(rose_neigh, lci, ROSE_NOT_OBTAINABLE, 0);
 936                 goto out;
 937         }
 938
 939         /*
 940          *      Route it to the next in line if we have an entry for it.
 941          */
 942         rose_route = rose_route_list;
 943         while (rose_route != NULL) {
 944                 if (rose_route->lci1 == lci &&
 945                     rose_route->neigh1 == rose_neigh) {
 946                         if (frametype == ROSE_CALL_REQUEST) {
 947                                 /* F6FBB - Remove an existing unused route */
 948                                 rose_remove_route(rose_route);
 949                                 break;
 950                         } else if (rose_route->neigh2 != NULL) {
 951                                 skb->data[0] &= 0xF0;
 952                                 skb->data[0] |= (rose_route->lci2 >> 8) & 0x0F;
 953                                 skb->data[1]  = (rose_route->lci2 >> 0) & 0xFF;
 954                                 rose_transmit_link(skb, rose_route->neigh2);
 955                                 if (frametype == ROSE_CLEAR_CONFIRMATION)
 956                                         rose_remove_route(rose_route);
 957                                 res = 1;
 958                                 goto out;
 959                         } else {
 960                                 if (frametype == ROSE_CLEAR_CONFIRMATION)
 961                                         rose_remove_route(rose_route);
 962                                 goto out;
 963                         }
 964                 }
 965                 if (rose_route->lci2 == lci &&
 966                     rose_route->neigh2 == rose_neigh) {
 967                         if (frametype == ROSE_CALL_REQUEST) {
 968                                 /* F6FBB - Remove an existing unused route */
 969                                 rose_remove_route(rose_route);
 970                                 break;
 971                         } else if (rose_route->neigh1 != NULL) {
 972                                 skb->data[0] &= 0xF0;
 973                                 skb->data[0] |= (rose_route->lci1 >> 8) & 0x0F;
 974                                 skb->data[1]  = (rose_route->lci1 >> 0) & 0xFF;
 975                                 rose_transmit_link(skb, rose_route->neigh1);
 976                                 if (frametype == ROSE_CLEAR_CONFIRMATION)
 977                                         rose_remove_route(rose_route);
 978                                 res = 1;
 979                                 goto out;
 980                         } else {
 981                                 if (frametype == ROSE_CLEAR_CONFIRMATION)
 982                                         rose_remove_route(rose_route);
 983                                 goto out;
 984                         }
 985                 }
 986                 rose_route = rose_route->next;
 987         }
 988
 989         /*
 990          *      We know that:
 991          *      1. The frame isn't for us,
 992          *      2. It isn't "owned" by any existing route.
 993          */
 994         if (frametype != ROSE_CALL_REQUEST) {   /* XXX */
 995                 res = 0;
 996                 goto out;
 997         }
 998
 999         len  = (((skb->data[3] >> 4) & 0x0F) + 1) / 2;
1000         len += (((skb->data[3] >> 0) & 0x0F) + 1) / 2;
1001
1002         memset(&facilities, 0x00, sizeof(struct rose_facilities_struct));
1003
1004         if (!rose_parse_facilities(skb->data + len + 4, &facilities)) {
1005                 rose_transmit_clear_request(rose_neigh, lci, ROSE_INVALID_FACILITY, 76);
1006                 goto out;
1007         }
1008
1009         /*
1010          *      Check for routing loops.
1011          */
1012         rose_route = rose_route_list;
1013         while (rose_route != NULL) {
1014                 if (rose_route->rand == facilities.rand &&
1015                     rosecmp(src_addr, &rose_route->src_addr) == 0 &&
1016                     ax25cmp(&facilities.dest_call, &rose_route->src_call) == 0 &&
1017                     ax25cmp(&facilities.source_call, &rose_route->dest_call) == 0) {
1018                         rose_transmit_clear_request(rose_neigh, lci, ROSE_NOT_OBTAINABLE, 120);
1019                         goto out;
1020                 }
1021                 rose_route = rose_route->next;
1022         }
1023
1024         if ((new_neigh = rose_get_neigh(dest_addr, &cause, &diagnostic)) == NULL) {
1025                 rose_transmit_clear_request(rose_neigh, lci, cause, diagnostic);
1026                 goto out;
1027         }
1028
1029         if ((new_lci = rose_new_lci(new_neigh)) == 0) {
1030                 rose_transmit_clear_request(rose_neigh, lci, ROSE_NETWORK_CONGESTION, 71);
1031                 goto out;
1032         }
1033
1034         if ((rose_route = kmalloc(sizeof(*rose_route), GFP_ATOMIC)) == NULL) {
1035                 rose_transmit_clear_request(rose_neigh, lci, ROSE_NETWORK_CONGESTION, 120);
1036                 goto out;
1037         }
1038
1039         rose_route->lci1      = lci;
1040         rose_route->src_addr  = *src_addr;
1041         rose_route->dest_addr = *dest_addr;
1042         rose_route->src_call  = facilities.dest_call;
1043         rose_route->dest_call = facilities.source_call;
1044         rose_route->rand      = facilities.rand;
1045         rose_route->neigh1    = rose_neigh;
1046         rose_route->lci2      = new_lci;
1047         rose_route->neigh2    = new_neigh;
1048
1049         rose_route->neigh1->use++;
1050         rose_route->neigh2->use++;
1051
1052         rose_route->next = rose_route_list;
1053         rose_route_list  = rose_route;
1054
1055         skb->data[0] &= 0xF0;
1056         skb->data[0] |= (rose_route->lci2 >> 8) & 0x0F;
1057         skb->data[1]  = (rose_route->lci2 >> 0) & 0xFF;
1058
1059         rose_transmit_link(skb, rose_route->neigh2);
1060         res = 1;
1061
1062 out:
1063         spin_unlock_bh(&rose_route_list_lock);
1064         spin_unlock_bh(&rose_neigh_list_lock);
1065         spin_unlock_bh(&rose_node_list_lock);
1066
1067         return res;
1068 }
1069
1070 #ifdef CONFIG_PROC_FS
1071
1072 static void *rose_node_start(struct seq_file *seq, loff_t *pos)
1073 {
1074         struct rose_node *rose_node;
1075         int i = 1;
1076
1077         spin_lock_bh(&rose_neigh_list_lock);
1078         if (*pos == 0)
1079                 return SEQ_START_TOKEN;
1080
1081         for (rose_node = rose_node_list; rose_node && i < *pos;
1082              rose_node = rose_node->next, ++i);
1083
1084         return (i == *pos) ? rose_node : NULL;
1085 }
1086
1087 static void *rose_node_next(struct seq_file *seq, void *v, loff_t *pos)
1088 {
1089         ++*pos;
1090
1091         return (v == SEQ_START_TOKEN) ? rose_node_list
1092                 : ((struct rose_node *)v)->next;
1093 }
1094
1095 static void rose_node_stop(struct seq_file *seq, void *v)
1096 {
1097         spin_unlock_bh(&rose_neigh_list_lock);
1098 }
1099
1100 static int rose_node_show(struct seq_file *seq, void *v)
1101 {
1102         int i;
1103
1104         if (v == SEQ_START_TOKEN)
1105                 seq_puts(seq, "address    mask n neigh neigh neigh\n");
1106         else {
1107                 const struct rose_node *rose_node = v;
1108                 /* if (rose_node->loopback) {
1109                         seq_printf(seq, "%-10s %04d 1 loopback\n",
1110                                 rose2asc(&rose_node->address),
1111                                 rose_node->mask);
1112                 } else { */
1113                         seq_printf(seq, "%-10s %04d %d",
1114                                 rose2asc(&rose_node->address),
1115                                 rose_node->mask,
1116                                 rose_node->count);
1117
1118                         for (i = 0; i < rose_node->count; i++)
1119                                 seq_printf(seq, " %05d",
1120                                         rose_node->neighbour[i]->number);
1121
1122                         seq_puts(seq, "\n");
1123                 /* } */
1124         }
1125         return 0;
1126 }
1127
1128 static struct seq_operations rose_node_seqops = {
1129         .start = rose_node_start,
1130         .next = rose_node_next,
1131         .stop = rose_node_stop,
1132         .show = rose_node_show,
1133 };
1134
1135 static int rose_nodes_open(struct inode *inode, struct file *file)
1136 {
1137         return seq_open(file, &rose_node_seqops);
1138 }
1139
1140 struct file_operations rose_nodes_fops = {
1141         .owner = THIS_MODULE,
1142         .open = rose_nodes_open,
1143         .read = seq_read,
1144         .llseek = seq_lseek,
1145         .release = seq_release,
1146 };
1147
1148 static void *rose_neigh_start(struct seq_file *seq, loff_t *pos)
1149 {
1150         struct rose_neigh *rose_neigh;
1151         int i = 1;
1152
1153         spin_lock_bh(&rose_neigh_list_lock);
1154         if (*pos == 0)
1155                 return SEQ_START_TOKEN;
1156
1157         for (rose_neigh = rose_neigh_list; rose_neigh && i < *pos;
1158              rose_neigh = rose_neigh->next, ++i);
1159
1160         return (i == *pos) ? rose_neigh : NULL;
1161 }
1162
1163 static void *rose_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
1164 {
1165         ++*pos;
1166
1167         return (v == SEQ_START_TOKEN) ? rose_neigh_list
1168                 : ((struct rose_neigh *)v)->next;
1169 }
1170
1171 static void rose_neigh_stop(struct seq_file *seq, void *v)
1172 {
1173         spin_unlock_bh(&rose_neigh_list_lock);
1174 }
1175
1176 static int rose_neigh_show(struct seq_file *seq, void *v)
1177 {
1178         char buf[11];
1179         int i;
1180
1181         if (v == SEQ_START_TOKEN)
1182                 seq_puts(seq,
1183                          "addr  callsign  dev  count use mode restart  t0  tf digipeaters\n");
1184         else {
1185                 struct rose_neigh *rose_neigh = v;
1186
1187                 /* if (!rose_neigh->loopback) { */
1188                 seq_printf(seq, "%05d %-9s %-4s   %3d %3d  %3s     %3s %3lu %3lu",
1189                            rose_neigh->number,
1190                            (rose_neigh->loopback) ? "RSLOOP-0" : ax2asc(buf, &rose_neigh->callsign),
1191                            rose_neigh->dev ? rose_neigh->dev->name : "???",
1192                            rose_neigh->count,
1193                            rose_neigh->use,
1194                            (rose_neigh->dce_mode) ? "DCE" : "DTE",
1195                            (rose_neigh->restarted) ? "yes" : "no",
1196                            ax25_display_timer(&rose_neigh->t0timer) / HZ,
1197                            ax25_display_timer(&rose_neigh->ftimer)  / HZ);
1198
1199                 if (rose_neigh->digipeat != NULL) {
1200                         for (i = 0; i < rose_neigh->digipeat->ndigi; i++)
1201                                 seq_printf(seq, " %s", ax2asc(buf, &rose_neigh->digipeat->calls[i]));
1202                 }
1203
1204                 seq_puts(seq, "\n");
1205         }
1206         return 0;
1207 }
1208
1209
1210 static struct seq_operations rose_neigh_seqops = {
1211         .start = rose_neigh_start,
1212         .next = rose_neigh_next,
1213         .stop = rose_neigh_stop,
1214         .show = rose_neigh_show,
1215 };
1216
1217 static int rose_neigh_open(struct inode *inode, struct file *file)
1218 {
1219         return seq_open(file, &rose_neigh_seqops);
1220 }
1221
1222 struct file_operations rose_neigh_fops = {
1223         .owner = THIS_MODULE,
1224         .open = rose_neigh_open,
1225         .read = seq_read,
1226         .llseek = seq_lseek,
1227         .release = seq_release,
1228 };
1229
1230
1231 static void *rose_route_start(struct seq_file *seq, loff_t *pos)
1232 {
1233         struct rose_route *rose_route;
1234         int i = 1;
1235
1236         spin_lock_bh(&rose_route_list_lock);
1237         if (*pos == 0)
1238                 return SEQ_START_TOKEN;
1239
1240         for (rose_route = rose_route_list; rose_route && i < *pos;
1241              rose_route = rose_route->next, ++i);
1242
1243         return (i == *pos) ? rose_route : NULL;
1244 }
1245
1246 static void *rose_route_next(struct seq_file *seq, void *v, loff_t *pos)
1247 {
1248         ++*pos;
1249
1250         return (v == SEQ_START_TOKEN) ? rose_route_list
1251                 : ((struct rose_route *)v)->next;
1252 }
1253
1254 static void rose_route_stop(struct seq_file *seq, void *v)
1255 {
1256         spin_unlock_bh(&rose_route_list_lock);
1257 }
1258
1259 static int rose_route_show(struct seq_file *seq, void *v)
1260 {
1261         char buf[11];
1262
1263         if (v == SEQ_START_TOKEN)
1264                 seq_puts(seq,
1265                          "lci  address     callsign   neigh  <-> lci  address     callsign   neigh\n");
1266         else {
1267                 struct rose_route *rose_route = v;
1268
1269                 if (rose_route->neigh1)
1270                         seq_printf(seq,
1271                                    "%3.3X  %-10s  %-9s  %05d      ",
1272                                    rose_route->lci1,
1273                                    rose2asc(&rose_route->src_addr),
1274                                    ax2asc(buf, &rose_route->src_call),
1275                                    rose_route->neigh1->number);
1276                 else
1277                         seq_puts(seq,
1278                                  "000  *           *          00000      ");
1279
1280                 if (rose_route->neigh2)
1281                         seq_printf(seq,
1282                                    "%3.3X  %-10s  %-9s  %05d\n",
1283                                 rose_route->lci2,
1284                                 rose2asc(&rose_route->dest_addr),
1285                                 ax2asc(buf, &rose_route->dest_call),
1286                                 rose_route->neigh2->number);
1287                  else
1288                          seq_puts(seq,
1289                                   "000  *           *          00000\n");
1290                 }
1291         return 0;
1292 }
1293
1294 static struct seq_operations rose_route_seqops = {
1295         .start = rose_route_start,
1296         .next = rose_route_next,
1297         .stop = rose_route_stop,
1298         .show = rose_route_show,
1299 };
1300
1301 static int rose_route_open(struct inode *inode, struct file *file)
1302 {
1303         return seq_open(file, &rose_route_seqops);
1304 }
1305
1306 struct file_operations rose_routes_fops = {
1307         .owner = THIS_MODULE,
1308         .open = rose_route_open,
1309         .read = seq_read,
1310         .llseek = seq_lseek,
1311         .release = seq_release,
1312 };
1313
1314 #endif /* CONFIG_PROC_FS */
1315
1316 /*
1317  *      Release all memory associated with ROSE routing structures.
1318  */
1319 void __exit rose_rt_free(void)
1320 {
1321         struct rose_neigh *s, *rose_neigh = rose_neigh_list;
1322         struct rose_node  *t, *rose_node  = rose_node_list;
1323         struct rose_route *u, *rose_route = rose_route_list;
1324
1325         while (rose_neigh != NULL) {
1326                 s          = rose_neigh;
1327                 rose_neigh = rose_neigh->next;
1328
1329                 rose_remove_neigh(s);
1330         }
1331
1332         while (rose_node != NULL) {
1333                 t         = rose_node;
1334                 rose_node = rose_node->next;
1335
1336                 rose_remove_node(t);
1337         }
1338
1339         while (rose_route != NULL) {
1340                 u          = rose_route;
1341                 rose_route = rose_route->next;
1342
1343                 rose_remove_route(u);
1344         }
1345 }