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