Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *
0004  * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
0005  * Copyright (C) Terry Dawson VK2KTJ (terry@animats.net)
0006  */
0007 #include <linux/errno.h>
0008 #include <linux/types.h>
0009 #include <linux/socket.h>
0010 #include <linux/in.h>
0011 #include <linux/kernel.h>
0012 #include <linux/timer.h>
0013 #include <linux/string.h>
0014 #include <linux/sockios.h>
0015 #include <linux/net.h>
0016 #include <linux/slab.h>
0017 #include <net/ax25.h>
0018 #include <linux/inet.h>
0019 #include <linux/netdevice.h>
0020 #include <net/arp.h>
0021 #include <linux/if_arp.h>
0022 #include <linux/skbuff.h>
0023 #include <net/sock.h>
0024 #include <net/tcp_states.h>
0025 #include <linux/uaccess.h>
0026 #include <linux/fcntl.h>
0027 #include <linux/termios.h>  /* For TIOCINQ/OUTQ */
0028 #include <linux/mm.h>
0029 #include <linux/interrupt.h>
0030 #include <linux/notifier.h>
0031 #include <linux/init.h>
0032 #include <net/rose.h>
0033 #include <linux/seq_file.h>
0034 #include <linux/export.h>
0035 
0036 static unsigned int rose_neigh_no = 1;
0037 
0038 static struct rose_node  *rose_node_list;
0039 static DEFINE_SPINLOCK(rose_node_list_lock);
0040 static struct rose_neigh *rose_neigh_list;
0041 static DEFINE_SPINLOCK(rose_neigh_list_lock);
0042 static struct rose_route *rose_route_list;
0043 static DEFINE_SPINLOCK(rose_route_list_lock);
0044 
0045 struct rose_neigh *rose_loopback_neigh;
0046 
0047 /*
0048  *  Add a new route to a node, and in the process add the node and the
0049  *  neighbour if it is new.
0050  */
0051 static int __must_check rose_add_node(struct rose_route_struct *rose_route,
0052     struct net_device *dev)
0053 {
0054     struct rose_node  *rose_node, *rose_tmpn, *rose_tmpp;
0055     struct rose_neigh *rose_neigh;
0056     int i, res = 0;
0057 
0058     spin_lock_bh(&rose_node_list_lock);
0059     spin_lock_bh(&rose_neigh_list_lock);
0060 
0061     rose_node = rose_node_list;
0062     while (rose_node != NULL) {
0063         if ((rose_node->mask == rose_route->mask) &&
0064             (rosecmpm(&rose_route->address, &rose_node->address,
0065                   rose_route->mask) == 0))
0066             break;
0067         rose_node = rose_node->next;
0068     }
0069 
0070     if (rose_node != NULL && rose_node->loopback) {
0071         res = -EINVAL;
0072         goto out;
0073     }
0074 
0075     rose_neigh = rose_neigh_list;
0076     while (rose_neigh != NULL) {
0077         if (ax25cmp(&rose_route->neighbour,
0078                 &rose_neigh->callsign) == 0 &&
0079             rose_neigh->dev == dev)
0080             break;
0081         rose_neigh = rose_neigh->next;
0082     }
0083 
0084     if (rose_neigh == NULL) {
0085         rose_neigh = kmalloc(sizeof(*rose_neigh), GFP_ATOMIC);
0086         if (rose_neigh == NULL) {
0087             res = -ENOMEM;
0088             goto out;
0089         }
0090 
0091         rose_neigh->callsign  = rose_route->neighbour;
0092         rose_neigh->digipeat  = NULL;
0093         rose_neigh->ax25      = NULL;
0094         rose_neigh->dev       = dev;
0095         rose_neigh->count     = 0;
0096         rose_neigh->use       = 0;
0097         rose_neigh->dce_mode  = 0;
0098         rose_neigh->loopback  = 0;
0099         rose_neigh->number    = rose_neigh_no++;
0100         rose_neigh->restarted = 0;
0101 
0102         skb_queue_head_init(&rose_neigh->queue);
0103 
0104         timer_setup(&rose_neigh->ftimer, NULL, 0);
0105         timer_setup(&rose_neigh->t0timer, NULL, 0);
0106 
0107         if (rose_route->ndigis != 0) {
0108             rose_neigh->digipeat =
0109                 kmalloc(sizeof(ax25_digi), GFP_ATOMIC);
0110             if (rose_neigh->digipeat == NULL) {
0111                 kfree(rose_neigh);
0112                 res = -ENOMEM;
0113                 goto out;
0114             }
0115 
0116             rose_neigh->digipeat->ndigi      = rose_route->ndigis;
0117             rose_neigh->digipeat->lastrepeat = -1;
0118 
0119             for (i = 0; i < rose_route->ndigis; i++) {
0120                 rose_neigh->digipeat->calls[i]    =
0121                     rose_route->digipeaters[i];
0122                 rose_neigh->digipeat->repeated[i] = 0;
0123             }
0124         }
0125 
0126         rose_neigh->next = rose_neigh_list;
0127         rose_neigh_list  = rose_neigh;
0128     }
0129 
0130     /*
0131      * This is a new node to be inserted into the list. Find where it needs
0132      * to be inserted into the list, and insert it. We want to be sure
0133      * to order the list in descending order of mask size to ensure that
0134      * later when we are searching this list the first match will be the
0135      * best match.
0136      */
0137     if (rose_node == NULL) {
0138         rose_tmpn = rose_node_list;
0139         rose_tmpp = NULL;
0140 
0141         while (rose_tmpn != NULL) {
0142             if (rose_tmpn->mask > rose_route->mask) {
0143                 rose_tmpp = rose_tmpn;
0144                 rose_tmpn = rose_tmpn->next;
0145             } else {
0146                 break;
0147             }
0148         }
0149 
0150         /* create new node */
0151         rose_node = kmalloc(sizeof(*rose_node), GFP_ATOMIC);
0152         if (rose_node == NULL) {
0153             res = -ENOMEM;
0154             goto out;
0155         }
0156 
0157         rose_node->address      = rose_route->address;
0158         rose_node->mask         = rose_route->mask;
0159         rose_node->count        = 1;
0160         rose_node->loopback     = 0;
0161         rose_node->neighbour[0] = rose_neigh;
0162 
0163         if (rose_tmpn == NULL) {
0164             if (rose_tmpp == NULL) {    /* Empty list */
0165                 rose_node_list  = rose_node;
0166                 rose_node->next = NULL;
0167             } else {
0168                 rose_tmpp->next = rose_node;
0169                 rose_node->next = NULL;
0170             }
0171         } else {
0172             if (rose_tmpp == NULL) {    /* 1st node */
0173                 rose_node->next = rose_node_list;
0174                 rose_node_list  = rose_node;
0175             } else {
0176                 rose_tmpp->next = rose_node;
0177                 rose_node->next = rose_tmpn;
0178             }
0179         }
0180         rose_neigh->count++;
0181 
0182         goto out;
0183     }
0184 
0185     /* We have space, slot it in */
0186     if (rose_node->count < 3) {
0187         rose_node->neighbour[rose_node->count] = rose_neigh;
0188         rose_node->count++;
0189         rose_neigh->count++;
0190     }
0191 
0192 out:
0193     spin_unlock_bh(&rose_neigh_list_lock);
0194     spin_unlock_bh(&rose_node_list_lock);
0195 
0196     return res;
0197 }
0198 
0199 /*
0200  * Caller is holding rose_node_list_lock.
0201  */
0202 static void rose_remove_node(struct rose_node *rose_node)
0203 {
0204     struct rose_node *s;
0205 
0206     if ((s = rose_node_list) == rose_node) {
0207         rose_node_list = rose_node->next;
0208         kfree(rose_node);
0209         return;
0210     }
0211 
0212     while (s != NULL && s->next != NULL) {
0213         if (s->next == rose_node) {
0214             s->next = rose_node->next;
0215             kfree(rose_node);
0216             return;
0217         }
0218 
0219         s = s->next;
0220     }
0221 }
0222 
0223 /*
0224  * Caller is holding rose_neigh_list_lock.
0225  */
0226 static void rose_remove_neigh(struct rose_neigh *rose_neigh)
0227 {
0228     struct rose_neigh *s;
0229 
0230     del_timer_sync(&rose_neigh->ftimer);
0231     del_timer_sync(&rose_neigh->t0timer);
0232 
0233     skb_queue_purge(&rose_neigh->queue);
0234 
0235     if ((s = rose_neigh_list) == rose_neigh) {
0236         rose_neigh_list = rose_neigh->next;
0237         if (rose_neigh->ax25)
0238             ax25_cb_put(rose_neigh->ax25);
0239         kfree(rose_neigh->digipeat);
0240         kfree(rose_neigh);
0241         return;
0242     }
0243 
0244     while (s != NULL && s->next != NULL) {
0245         if (s->next == rose_neigh) {
0246             s->next = rose_neigh->next;
0247             if (rose_neigh->ax25)
0248                 ax25_cb_put(rose_neigh->ax25);
0249             kfree(rose_neigh->digipeat);
0250             kfree(rose_neigh);
0251             return;
0252         }
0253 
0254         s = s->next;
0255     }
0256 }
0257 
0258 /*
0259  * Caller is holding rose_route_list_lock.
0260  */
0261 static void rose_remove_route(struct rose_route *rose_route)
0262 {
0263     struct rose_route *s;
0264 
0265     if (rose_route->neigh1 != NULL)
0266         rose_route->neigh1->use--;
0267 
0268     if (rose_route->neigh2 != NULL)
0269         rose_route->neigh2->use--;
0270 
0271     if ((s = rose_route_list) == rose_route) {
0272         rose_route_list = rose_route->next;
0273         kfree(rose_route);
0274         return;
0275     }
0276 
0277     while (s != NULL && s->next != NULL) {
0278         if (s->next == rose_route) {
0279             s->next = rose_route->next;
0280             kfree(rose_route);
0281             return;
0282         }
0283 
0284         s = s->next;
0285     }
0286 }
0287 
0288 /*
0289  *  "Delete" a node. Strictly speaking remove a route to a node. The node
0290  *  is only deleted if no routes are left to it.
0291  */
0292 static int rose_del_node(struct rose_route_struct *rose_route,
0293     struct net_device *dev)
0294 {
0295     struct rose_node  *rose_node;
0296     struct rose_neigh *rose_neigh;
0297     int i, err = 0;
0298 
0299     spin_lock_bh(&rose_node_list_lock);
0300     spin_lock_bh(&rose_neigh_list_lock);
0301 
0302     rose_node = rose_node_list;
0303     while (rose_node != NULL) {
0304         if ((rose_node->mask == rose_route->mask) &&
0305             (rosecmpm(&rose_route->address, &rose_node->address,
0306                   rose_route->mask) == 0))
0307             break;
0308         rose_node = rose_node->next;
0309     }
0310 
0311     if (rose_node == NULL || rose_node->loopback) {
0312         err = -EINVAL;
0313         goto out;
0314     }
0315 
0316     rose_neigh = rose_neigh_list;
0317     while (rose_neigh != NULL) {
0318         if (ax25cmp(&rose_route->neighbour,
0319                 &rose_neigh->callsign) == 0 &&
0320             rose_neigh->dev == dev)
0321             break;
0322         rose_neigh = rose_neigh->next;
0323     }
0324 
0325     if (rose_neigh == NULL) {
0326         err = -EINVAL;
0327         goto out;
0328     }
0329 
0330     for (i = 0; i < rose_node->count; i++) {
0331         if (rose_node->neighbour[i] == rose_neigh) {
0332             rose_neigh->count--;
0333 
0334             if (rose_neigh->count == 0 && rose_neigh->use == 0)
0335                 rose_remove_neigh(rose_neigh);
0336 
0337             rose_node->count--;
0338 
0339             if (rose_node->count == 0) {
0340                 rose_remove_node(rose_node);
0341             } else {
0342                 switch (i) {
0343                 case 0:
0344                     rose_node->neighbour[0] =
0345                         rose_node->neighbour[1];
0346                     fallthrough;
0347                 case 1:
0348                     rose_node->neighbour[1] =
0349                         rose_node->neighbour[2];
0350                     break;
0351                 case 2:
0352                     break;
0353                 }
0354             }
0355             goto out;
0356         }
0357     }
0358     err = -EINVAL;
0359 
0360 out:
0361     spin_unlock_bh(&rose_neigh_list_lock);
0362     spin_unlock_bh(&rose_node_list_lock);
0363 
0364     return err;
0365 }
0366 
0367 /*
0368  *  Add the loopback neighbour.
0369  */
0370 void rose_add_loopback_neigh(void)
0371 {
0372     struct rose_neigh *sn;
0373 
0374     rose_loopback_neigh = kmalloc(sizeof(struct rose_neigh), GFP_KERNEL);
0375     if (!rose_loopback_neigh)
0376         return;
0377     sn = rose_loopback_neigh;
0378 
0379     sn->callsign  = null_ax25_address;
0380     sn->digipeat  = NULL;
0381     sn->ax25      = NULL;
0382     sn->dev       = NULL;
0383     sn->count     = 0;
0384     sn->use       = 0;
0385     sn->dce_mode  = 1;
0386     sn->loopback  = 1;
0387     sn->number    = rose_neigh_no++;
0388     sn->restarted = 1;
0389 
0390     skb_queue_head_init(&sn->queue);
0391 
0392     timer_setup(&sn->ftimer, NULL, 0);
0393     timer_setup(&sn->t0timer, NULL, 0);
0394 
0395     spin_lock_bh(&rose_neigh_list_lock);
0396     sn->next = rose_neigh_list;
0397     rose_neigh_list           = sn;
0398     spin_unlock_bh(&rose_neigh_list_lock);
0399 }
0400 
0401 /*
0402  *  Add a loopback node.
0403  */
0404 int rose_add_loopback_node(const rose_address *address)
0405 {
0406     struct rose_node *rose_node;
0407     int err = 0;
0408 
0409     spin_lock_bh(&rose_node_list_lock);
0410 
0411     rose_node = rose_node_list;
0412     while (rose_node != NULL) {
0413         if ((rose_node->mask == 10) &&
0414              (rosecmpm(address, &rose_node->address, 10) == 0) &&
0415              rose_node->loopback)
0416             break;
0417         rose_node = rose_node->next;
0418     }
0419 
0420     if (rose_node != NULL)
0421         goto out;
0422 
0423     if ((rose_node = kmalloc(sizeof(*rose_node), GFP_ATOMIC)) == NULL) {
0424         err = -ENOMEM;
0425         goto out;
0426     }
0427 
0428     rose_node->address      = *address;
0429     rose_node->mask         = 10;
0430     rose_node->count        = 1;
0431     rose_node->loopback     = 1;
0432     rose_node->neighbour[0] = rose_loopback_neigh;
0433 
0434     /* Insert at the head of list. Address is always mask=10 */
0435     rose_node->next = rose_node_list;
0436     rose_node_list  = rose_node;
0437 
0438     rose_loopback_neigh->count++;
0439 
0440 out:
0441     spin_unlock_bh(&rose_node_list_lock);
0442 
0443     return err;
0444 }
0445 
0446 /*
0447  *  Delete a loopback node.
0448  */
0449 void rose_del_loopback_node(const rose_address *address)
0450 {
0451     struct rose_node *rose_node;
0452 
0453     spin_lock_bh(&rose_node_list_lock);
0454 
0455     rose_node = rose_node_list;
0456     while (rose_node != NULL) {
0457         if ((rose_node->mask == 10) &&
0458             (rosecmpm(address, &rose_node->address, 10) == 0) &&
0459             rose_node->loopback)
0460             break;
0461         rose_node = rose_node->next;
0462     }
0463 
0464     if (rose_node == NULL)
0465         goto out;
0466 
0467     rose_remove_node(rose_node);
0468 
0469     rose_loopback_neigh->count--;
0470 
0471 out:
0472     spin_unlock_bh(&rose_node_list_lock);
0473 }
0474 
0475 /*
0476  *  A device has been removed. Remove its routes and neighbours.
0477  */
0478 void rose_rt_device_down(struct net_device *dev)
0479 {
0480     struct rose_neigh *s, *rose_neigh;
0481     struct rose_node  *t, *rose_node;
0482     int i;
0483 
0484     spin_lock_bh(&rose_node_list_lock);
0485     spin_lock_bh(&rose_neigh_list_lock);
0486     rose_neigh = rose_neigh_list;
0487     while (rose_neigh != NULL) {
0488         s          = rose_neigh;
0489         rose_neigh = rose_neigh->next;
0490 
0491         if (s->dev != dev)
0492             continue;
0493 
0494         rose_node = rose_node_list;
0495 
0496         while (rose_node != NULL) {
0497             t         = rose_node;
0498             rose_node = rose_node->next;
0499 
0500             for (i = 0; i < t->count; i++) {
0501                 if (t->neighbour[i] != s)
0502                     continue;
0503 
0504                 t->count--;
0505 
0506                 switch (i) {
0507                 case 0:
0508                     t->neighbour[0] = t->neighbour[1];
0509                     fallthrough;
0510                 case 1:
0511                     t->neighbour[1] = t->neighbour[2];
0512                     break;
0513                 case 2:
0514                     break;
0515                 }
0516             }
0517 
0518             if (t->count <= 0)
0519                 rose_remove_node(t);
0520         }
0521 
0522         rose_remove_neigh(s);
0523     }
0524     spin_unlock_bh(&rose_neigh_list_lock);
0525     spin_unlock_bh(&rose_node_list_lock);
0526 }
0527 
0528 #if 0 /* Currently unused */
0529 /*
0530  *  A device has been removed. Remove its links.
0531  */
0532 void rose_route_device_down(struct net_device *dev)
0533 {
0534     struct rose_route *s, *rose_route;
0535 
0536     spin_lock_bh(&rose_route_list_lock);
0537     rose_route = rose_route_list;
0538     while (rose_route != NULL) {
0539         s          = rose_route;
0540         rose_route = rose_route->next;
0541 
0542         if (s->neigh1->dev == dev || s->neigh2->dev == dev)
0543             rose_remove_route(s);
0544     }
0545     spin_unlock_bh(&rose_route_list_lock);
0546 }
0547 #endif
0548 
0549 /*
0550  *  Clear all nodes and neighbours out, except for neighbours with
0551  *  active connections going through them.
0552  *  Do not clear loopback neighbour and nodes.
0553  */
0554 static int rose_clear_routes(void)
0555 {
0556     struct rose_neigh *s, *rose_neigh;
0557     struct rose_node  *t, *rose_node;
0558 
0559     spin_lock_bh(&rose_node_list_lock);
0560     spin_lock_bh(&rose_neigh_list_lock);
0561 
0562     rose_neigh = rose_neigh_list;
0563     rose_node  = rose_node_list;
0564 
0565     while (rose_node != NULL) {
0566         t         = rose_node;
0567         rose_node = rose_node->next;
0568         if (!t->loopback)
0569             rose_remove_node(t);
0570     }
0571 
0572     while (rose_neigh != NULL) {
0573         s          = rose_neigh;
0574         rose_neigh = rose_neigh->next;
0575 
0576         if (s->use == 0 && !s->loopback) {
0577             s->count = 0;
0578             rose_remove_neigh(s);
0579         }
0580     }
0581 
0582     spin_unlock_bh(&rose_neigh_list_lock);
0583     spin_unlock_bh(&rose_node_list_lock);
0584 
0585     return 0;
0586 }
0587 
0588 /*
0589  *  Check that the device given is a valid AX.25 interface that is "up".
0590  *  called with RTNL
0591  */
0592 static struct net_device *rose_ax25_dev_find(char *devname)
0593 {
0594     struct net_device *dev;
0595 
0596     if ((dev = __dev_get_by_name(&init_net, devname)) == NULL)
0597         return NULL;
0598 
0599     if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
0600         return dev;
0601 
0602     return NULL;
0603 }
0604 
0605 /*
0606  *  Find the first active ROSE device, usually "rose0".
0607  */
0608 struct net_device *rose_dev_first(void)
0609 {
0610     struct net_device *dev, *first = NULL;
0611 
0612     rcu_read_lock();
0613     for_each_netdev_rcu(&init_net, dev) {
0614         if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE)
0615             if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
0616                 first = dev;
0617     }
0618     if (first)
0619         dev_hold(first);
0620     rcu_read_unlock();
0621 
0622     return first;
0623 }
0624 
0625 /*
0626  *  Find the ROSE device for the given address.
0627  */
0628 struct net_device *rose_dev_get(rose_address *addr)
0629 {
0630     struct net_device *dev;
0631 
0632     rcu_read_lock();
0633     for_each_netdev_rcu(&init_net, dev) {
0634         if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE &&
0635             rosecmp(addr, (const rose_address *)dev->dev_addr) == 0) {
0636             dev_hold(dev);
0637             goto out;
0638         }
0639     }
0640     dev = NULL;
0641 out:
0642     rcu_read_unlock();
0643     return dev;
0644 }
0645 
0646 static int rose_dev_exists(rose_address *addr)
0647 {
0648     struct net_device *dev;
0649 
0650     rcu_read_lock();
0651     for_each_netdev_rcu(&init_net, dev) {
0652         if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE &&
0653             rosecmp(addr, (const rose_address *)dev->dev_addr) == 0)
0654             goto out;
0655     }
0656     dev = NULL;
0657 out:
0658     rcu_read_unlock();
0659     return dev != NULL;
0660 }
0661 
0662 
0663 
0664 
0665 struct rose_route *rose_route_free_lci(unsigned int lci, struct rose_neigh *neigh)
0666 {
0667     struct rose_route *rose_route;
0668 
0669     for (rose_route = rose_route_list; rose_route != NULL; rose_route = rose_route->next)
0670         if ((rose_route->neigh1 == neigh && rose_route->lci1 == lci) ||
0671             (rose_route->neigh2 == neigh && rose_route->lci2 == lci))
0672             return rose_route;
0673 
0674     return NULL;
0675 }
0676 
0677 /*
0678  *  Find a neighbour or a route given a ROSE address.
0679  */
0680 struct rose_neigh *rose_get_neigh(rose_address *addr, unsigned char *cause,
0681     unsigned char *diagnostic, int route_frame)
0682 {
0683     struct rose_neigh *res = NULL;
0684     struct rose_node *node;
0685     int failed = 0;
0686     int i;
0687 
0688     if (!route_frame) spin_lock_bh(&rose_node_list_lock);
0689     for (node = rose_node_list; node != NULL; node = node->next) {
0690         if (rosecmpm(addr, &node->address, node->mask) == 0) {
0691             for (i = 0; i < node->count; i++) {
0692                 if (node->neighbour[i]->restarted) {
0693                     res = node->neighbour[i];
0694                     goto out;
0695                 }
0696             }
0697         }
0698     }
0699     if (!route_frame) { /* connect request */
0700         for (node = rose_node_list; node != NULL; node = node->next) {
0701             if (rosecmpm(addr, &node->address, node->mask) == 0) {
0702                 for (i = 0; i < node->count; i++) {
0703                     if (!rose_ftimer_running(node->neighbour[i])) {
0704                         res = node->neighbour[i];
0705                         goto out;
0706                     }
0707                     failed = 1;
0708                 }
0709             }
0710         }
0711     }
0712 
0713     if (failed) {
0714         *cause      = ROSE_OUT_OF_ORDER;
0715         *diagnostic = 0;
0716     } else {
0717         *cause      = ROSE_NOT_OBTAINABLE;
0718         *diagnostic = 0;
0719     }
0720 
0721 out:
0722     if (!route_frame) spin_unlock_bh(&rose_node_list_lock);
0723     return res;
0724 }
0725 
0726 /*
0727  *  Handle the ioctls that control the routing functions.
0728  */
0729 int rose_rt_ioctl(unsigned int cmd, void __user *arg)
0730 {
0731     struct rose_route_struct rose_route;
0732     struct net_device *dev;
0733     int err;
0734 
0735     switch (cmd) {
0736     case SIOCADDRT:
0737         if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
0738             return -EFAULT;
0739         if ((dev = rose_ax25_dev_find(rose_route.device)) == NULL)
0740             return -EINVAL;
0741         if (rose_dev_exists(&rose_route.address)) /* Can't add routes to ourself */
0742             return -EINVAL;
0743         if (rose_route.mask > 10) /* Mask can't be more than 10 digits */
0744             return -EINVAL;
0745         if (rose_route.ndigis > AX25_MAX_DIGIS)
0746             return -EINVAL;
0747         err = rose_add_node(&rose_route, dev);
0748         return err;
0749 
0750     case SIOCDELRT:
0751         if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
0752             return -EFAULT;
0753         if ((dev = rose_ax25_dev_find(rose_route.device)) == NULL)
0754             return -EINVAL;
0755         err = rose_del_node(&rose_route, dev);
0756         return err;
0757 
0758     case SIOCRSCLRRT:
0759         return rose_clear_routes();
0760 
0761     default:
0762         return -EINVAL;
0763     }
0764 
0765     return 0;
0766 }
0767 
0768 static void rose_del_route_by_neigh(struct rose_neigh *rose_neigh)
0769 {
0770     struct rose_route *rose_route, *s;
0771 
0772     rose_neigh->restarted = 0;
0773 
0774     rose_stop_t0timer(rose_neigh);
0775     rose_start_ftimer(rose_neigh);
0776 
0777     skb_queue_purge(&rose_neigh->queue);
0778 
0779     spin_lock_bh(&rose_route_list_lock);
0780 
0781     rose_route = rose_route_list;
0782 
0783     while (rose_route != NULL) {
0784         if ((rose_route->neigh1 == rose_neigh && rose_route->neigh2 == rose_neigh) ||
0785             (rose_route->neigh1 == rose_neigh && rose_route->neigh2 == NULL)       ||
0786             (rose_route->neigh2 == rose_neigh && rose_route->neigh1 == NULL)) {
0787             s = rose_route->next;
0788             rose_remove_route(rose_route);
0789             rose_route = s;
0790             continue;
0791         }
0792 
0793         if (rose_route->neigh1 == rose_neigh) {
0794             rose_route->neigh1->use--;
0795             rose_route->neigh1 = NULL;
0796             rose_transmit_clear_request(rose_route->neigh2, rose_route->lci2, ROSE_OUT_OF_ORDER, 0);
0797         }
0798 
0799         if (rose_route->neigh2 == rose_neigh) {
0800             rose_route->neigh2->use--;
0801             rose_route->neigh2 = NULL;
0802             rose_transmit_clear_request(rose_route->neigh1, rose_route->lci1, ROSE_OUT_OF_ORDER, 0);
0803         }
0804 
0805         rose_route = rose_route->next;
0806     }
0807     spin_unlock_bh(&rose_route_list_lock);
0808 }
0809 
0810 /*
0811  *  A level 2 link has timed out, therefore it appears to be a poor link,
0812  *  then don't use that neighbour until it is reset. Blow away all through
0813  *  routes and connections using this route.
0814  */
0815 void rose_link_failed(ax25_cb *ax25, int reason)
0816 {
0817     struct rose_neigh *rose_neigh;
0818 
0819     spin_lock_bh(&rose_neigh_list_lock);
0820     rose_neigh = rose_neigh_list;
0821     while (rose_neigh != NULL) {
0822         if (rose_neigh->ax25 == ax25)
0823             break;
0824         rose_neigh = rose_neigh->next;
0825     }
0826 
0827     if (rose_neigh != NULL) {
0828         rose_neigh->ax25 = NULL;
0829         ax25_cb_put(ax25);
0830 
0831         rose_del_route_by_neigh(rose_neigh);
0832         rose_kill_by_neigh(rose_neigh);
0833     }
0834     spin_unlock_bh(&rose_neigh_list_lock);
0835 }
0836 
0837 /*
0838  *  A device has been "downed" remove its link status. Blow away all
0839  *  through routes and connections that use this device.
0840  */
0841 void rose_link_device_down(struct net_device *dev)
0842 {
0843     struct rose_neigh *rose_neigh;
0844 
0845     for (rose_neigh = rose_neigh_list; rose_neigh != NULL; rose_neigh = rose_neigh->next) {
0846         if (rose_neigh->dev == dev) {
0847             rose_del_route_by_neigh(rose_neigh);
0848             rose_kill_by_neigh(rose_neigh);
0849         }
0850     }
0851 }
0852 
0853 /*
0854  *  Route a frame to an appropriate AX.25 connection.
0855  *  A NULL ax25_cb indicates an internally generated frame.
0856  */
0857 int rose_route_frame(struct sk_buff *skb, ax25_cb *ax25)
0858 {
0859     struct rose_neigh *rose_neigh, *new_neigh;
0860     struct rose_route *rose_route;
0861     struct rose_facilities_struct facilities;
0862     rose_address *src_addr, *dest_addr;
0863     struct sock *sk;
0864     unsigned short frametype;
0865     unsigned int lci, new_lci;
0866     unsigned char cause, diagnostic;
0867     struct net_device *dev;
0868     int res = 0;
0869     char buf[11];
0870 
0871     if (skb->len < ROSE_MIN_LEN)
0872         return res;
0873 
0874     if (!ax25)
0875         return rose_loopback_queue(skb, NULL);
0876 
0877     frametype = skb->data[2];
0878     lci = ((skb->data[0] << 8) & 0xF00) + ((skb->data[1] << 0) & 0x0FF);
0879     if (frametype == ROSE_CALL_REQUEST &&
0880         (skb->len <= ROSE_CALL_REQ_FACILITIES_OFF ||
0881          skb->data[ROSE_CALL_REQ_ADDR_LEN_OFF] !=
0882          ROSE_CALL_REQ_ADDR_LEN_VAL))
0883         return res;
0884     src_addr  = (rose_address *)(skb->data + ROSE_CALL_REQ_SRC_ADDR_OFF);
0885     dest_addr = (rose_address *)(skb->data + ROSE_CALL_REQ_DEST_ADDR_OFF);
0886 
0887     spin_lock_bh(&rose_neigh_list_lock);
0888     spin_lock_bh(&rose_route_list_lock);
0889 
0890     rose_neigh = rose_neigh_list;
0891     while (rose_neigh != NULL) {
0892         if (ax25cmp(&ax25->dest_addr, &rose_neigh->callsign) == 0 &&
0893             ax25->ax25_dev->dev == rose_neigh->dev)
0894             break;
0895         rose_neigh = rose_neigh->next;
0896     }
0897 
0898     if (rose_neigh == NULL) {
0899         printk("rose_route : unknown neighbour or device %s\n",
0900                ax2asc(buf, &ax25->dest_addr));
0901         goto out;
0902     }
0903 
0904     /*
0905      *  Obviously the link is working, halt the ftimer.
0906      */
0907     rose_stop_ftimer(rose_neigh);
0908 
0909     /*
0910      *  LCI of zero is always for us, and its always a restart
0911      *  frame.
0912      */
0913     if (lci == 0) {
0914         rose_link_rx_restart(skb, rose_neigh, frametype);
0915         goto out;
0916     }
0917 
0918     /*
0919      *  Find an existing socket.
0920      */
0921     if ((sk = rose_find_socket(lci, rose_neigh)) != NULL) {
0922         if (frametype == ROSE_CALL_REQUEST) {
0923             struct rose_sock *rose = rose_sk(sk);
0924 
0925             /* Remove an existing unused socket */
0926             rose_clear_queues(sk);
0927             rose->cause  = ROSE_NETWORK_CONGESTION;
0928             rose->diagnostic = 0;
0929             rose->neighbour->use--;
0930             rose->neighbour  = NULL;
0931             rose->lci    = 0;
0932             rose->state  = ROSE_STATE_0;
0933             sk->sk_state     = TCP_CLOSE;
0934             sk->sk_err   = 0;
0935             sk->sk_shutdown  |= SEND_SHUTDOWN;
0936             if (!sock_flag(sk, SOCK_DEAD)) {
0937                 sk->sk_state_change(sk);
0938                 sock_set_flag(sk, SOCK_DEAD);
0939             }
0940         }
0941         else {
0942             skb_reset_transport_header(skb);
0943             res = rose_process_rx_frame(sk, skb);
0944             goto out;
0945         }
0946     }
0947 
0948     /*
0949      *  Is is a Call Request and is it for us ?
0950      */
0951     if (frametype == ROSE_CALL_REQUEST)
0952         if ((dev = rose_dev_get(dest_addr)) != NULL) {
0953             res = rose_rx_call_request(skb, dev, rose_neigh, lci);
0954             dev_put(dev);
0955             goto out;
0956         }
0957 
0958     if (!sysctl_rose_routing_control) {
0959         rose_transmit_clear_request(rose_neigh, lci, ROSE_NOT_OBTAINABLE, 0);
0960         goto out;
0961     }
0962 
0963     /*
0964      *  Route it to the next in line if we have an entry for it.
0965      */
0966     rose_route = rose_route_list;
0967     while (rose_route != NULL) {
0968         if (rose_route->lci1 == lci &&
0969             rose_route->neigh1 == rose_neigh) {
0970             if (frametype == ROSE_CALL_REQUEST) {
0971                 /* F6FBB - Remove an existing unused route */
0972                 rose_remove_route(rose_route);
0973                 break;
0974             } else if (rose_route->neigh2 != NULL) {
0975                 skb->data[0] &= 0xF0;
0976                 skb->data[0] |= (rose_route->lci2 >> 8) & 0x0F;
0977                 skb->data[1]  = (rose_route->lci2 >> 0) & 0xFF;
0978                 rose_transmit_link(skb, rose_route->neigh2);
0979                 if (frametype == ROSE_CLEAR_CONFIRMATION)
0980                     rose_remove_route(rose_route);
0981                 res = 1;
0982                 goto out;
0983             } else {
0984                 if (frametype == ROSE_CLEAR_CONFIRMATION)
0985                     rose_remove_route(rose_route);
0986                 goto out;
0987             }
0988         }
0989         if (rose_route->lci2 == lci &&
0990             rose_route->neigh2 == rose_neigh) {
0991             if (frametype == ROSE_CALL_REQUEST) {
0992                 /* F6FBB - Remove an existing unused route */
0993                 rose_remove_route(rose_route);
0994                 break;
0995             } else if (rose_route->neigh1 != NULL) {
0996                 skb->data[0] &= 0xF0;
0997                 skb->data[0] |= (rose_route->lci1 >> 8) & 0x0F;
0998                 skb->data[1]  = (rose_route->lci1 >> 0) & 0xFF;
0999                 rose_transmit_link(skb, rose_route->neigh1);
1000                 if (frametype == ROSE_CLEAR_CONFIRMATION)
1001                     rose_remove_route(rose_route);
1002                 res = 1;
1003                 goto out;
1004             } else {
1005                 if (frametype == ROSE_CLEAR_CONFIRMATION)
1006                     rose_remove_route(rose_route);
1007                 goto out;
1008             }
1009         }
1010         rose_route = rose_route->next;
1011     }
1012 
1013     /*
1014      *  We know that:
1015      *  1. The frame isn't for us,
1016      *  2. It isn't "owned" by any existing route.
1017      */
1018     if (frametype != ROSE_CALL_REQUEST) {   /* XXX */
1019         res = 0;
1020         goto out;
1021     }
1022 
1023     memset(&facilities, 0x00, sizeof(struct rose_facilities_struct));
1024 
1025     if (!rose_parse_facilities(skb->data + ROSE_CALL_REQ_FACILITIES_OFF,
1026                    skb->len - ROSE_CALL_REQ_FACILITIES_OFF,
1027                    &facilities)) {
1028         rose_transmit_clear_request(rose_neigh, lci, ROSE_INVALID_FACILITY, 76);
1029         goto out;
1030     }
1031 
1032     /*
1033      *  Check for routing loops.
1034      */
1035     rose_route = rose_route_list;
1036     while (rose_route != NULL) {
1037         if (rose_route->rand == facilities.rand &&
1038             rosecmp(src_addr, &rose_route->src_addr) == 0 &&
1039             ax25cmp(&facilities.dest_call, &rose_route->src_call) == 0 &&
1040             ax25cmp(&facilities.source_call, &rose_route->dest_call) == 0) {
1041             rose_transmit_clear_request(rose_neigh, lci, ROSE_NOT_OBTAINABLE, 120);
1042             goto out;
1043         }
1044         rose_route = rose_route->next;
1045     }
1046 
1047     if ((new_neigh = rose_get_neigh(dest_addr, &cause, &diagnostic, 1)) == NULL) {
1048         rose_transmit_clear_request(rose_neigh, lci, cause, diagnostic);
1049         goto out;
1050     }
1051 
1052     if ((new_lci = rose_new_lci(new_neigh)) == 0) {
1053         rose_transmit_clear_request(rose_neigh, lci, ROSE_NETWORK_CONGESTION, 71);
1054         goto out;
1055     }
1056 
1057     if ((rose_route = kmalloc(sizeof(*rose_route), GFP_ATOMIC)) == NULL) {
1058         rose_transmit_clear_request(rose_neigh, lci, ROSE_NETWORK_CONGESTION, 120);
1059         goto out;
1060     }
1061 
1062     rose_route->lci1      = lci;
1063     rose_route->src_addr  = *src_addr;
1064     rose_route->dest_addr = *dest_addr;
1065     rose_route->src_call  = facilities.dest_call;
1066     rose_route->dest_call = facilities.source_call;
1067     rose_route->rand      = facilities.rand;
1068     rose_route->neigh1    = rose_neigh;
1069     rose_route->lci2      = new_lci;
1070     rose_route->neigh2    = new_neigh;
1071 
1072     rose_route->neigh1->use++;
1073     rose_route->neigh2->use++;
1074 
1075     rose_route->next = rose_route_list;
1076     rose_route_list  = rose_route;
1077 
1078     skb->data[0] &= 0xF0;
1079     skb->data[0] |= (rose_route->lci2 >> 8) & 0x0F;
1080     skb->data[1]  = (rose_route->lci2 >> 0) & 0xFF;
1081 
1082     rose_transmit_link(skb, rose_route->neigh2);
1083     res = 1;
1084 
1085 out:
1086     spin_unlock_bh(&rose_route_list_lock);
1087     spin_unlock_bh(&rose_neigh_list_lock);
1088 
1089     return res;
1090 }
1091 
1092 #ifdef CONFIG_PROC_FS
1093 
1094 static void *rose_node_start(struct seq_file *seq, loff_t *pos)
1095     __acquires(rose_node_list_lock)
1096 {
1097     struct rose_node *rose_node;
1098     int i = 1;
1099 
1100     spin_lock_bh(&rose_node_list_lock);
1101     if (*pos == 0)
1102         return SEQ_START_TOKEN;
1103 
1104     for (rose_node = rose_node_list; rose_node && i < *pos;
1105          rose_node = rose_node->next, ++i);
1106 
1107     return (i == *pos) ? rose_node : NULL;
1108 }
1109 
1110 static void *rose_node_next(struct seq_file *seq, void *v, loff_t *pos)
1111 {
1112     ++*pos;
1113 
1114     return (v == SEQ_START_TOKEN) ? rose_node_list
1115         : ((struct rose_node *)v)->next;
1116 }
1117 
1118 static void rose_node_stop(struct seq_file *seq, void *v)
1119     __releases(rose_node_list_lock)
1120 {
1121     spin_unlock_bh(&rose_node_list_lock);
1122 }
1123 
1124 static int rose_node_show(struct seq_file *seq, void *v)
1125 {
1126     char rsbuf[11];
1127     int i;
1128 
1129     if (v == SEQ_START_TOKEN)
1130         seq_puts(seq, "address    mask n neigh neigh neigh\n");
1131     else {
1132         const struct rose_node *rose_node = v;
1133         seq_printf(seq, "%-10s %04d %d",
1134                rose2asc(rsbuf, &rose_node->address),
1135                rose_node->mask,
1136                rose_node->count);
1137 
1138         for (i = 0; i < rose_node->count; i++)
1139             seq_printf(seq, " %05d", rose_node->neighbour[i]->number);
1140 
1141         seq_puts(seq, "\n");
1142     }
1143     return 0;
1144 }
1145 
1146 const struct seq_operations rose_node_seqops = {
1147     .start = rose_node_start,
1148     .next = rose_node_next,
1149     .stop = rose_node_stop,
1150     .show = rose_node_show,
1151 };
1152 
1153 static void *rose_neigh_start(struct seq_file *seq, loff_t *pos)
1154     __acquires(rose_neigh_list_lock)
1155 {
1156     struct rose_neigh *rose_neigh;
1157     int i = 1;
1158 
1159     spin_lock_bh(&rose_neigh_list_lock);
1160     if (*pos == 0)
1161         return SEQ_START_TOKEN;
1162 
1163     for (rose_neigh = rose_neigh_list; rose_neigh && i < *pos;
1164          rose_neigh = rose_neigh->next, ++i);
1165 
1166     return (i == *pos) ? rose_neigh : NULL;
1167 }
1168 
1169 static void *rose_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
1170 {
1171     ++*pos;
1172 
1173     return (v == SEQ_START_TOKEN) ? rose_neigh_list
1174         : ((struct rose_neigh *)v)->next;
1175 }
1176 
1177 static void rose_neigh_stop(struct seq_file *seq, void *v)
1178     __releases(rose_neigh_list_lock)
1179 {
1180     spin_unlock_bh(&rose_neigh_list_lock);
1181 }
1182 
1183 static int rose_neigh_show(struct seq_file *seq, void *v)
1184 {
1185     char buf[11];
1186     int i;
1187 
1188     if (v == SEQ_START_TOKEN)
1189         seq_puts(seq,
1190              "addr  callsign  dev  count use mode restart  t0  tf digipeaters\n");
1191     else {
1192         struct rose_neigh *rose_neigh = v;
1193 
1194         /* if (!rose_neigh->loopback) { */
1195         seq_printf(seq, "%05d %-9s %-4s   %3d %3d  %3s     %3s %3lu %3lu",
1196                rose_neigh->number,
1197                (rose_neigh->loopback) ? "RSLOOP-0" : ax2asc(buf, &rose_neigh->callsign),
1198                rose_neigh->dev ? rose_neigh->dev->name : "???",
1199                rose_neigh->count,
1200                rose_neigh->use,
1201                (rose_neigh->dce_mode) ? "DCE" : "DTE",
1202                (rose_neigh->restarted) ? "yes" : "no",
1203                ax25_display_timer(&rose_neigh->t0timer) / HZ,
1204                ax25_display_timer(&rose_neigh->ftimer)  / HZ);
1205 
1206         if (rose_neigh->digipeat != NULL) {
1207             for (i = 0; i < rose_neigh->digipeat->ndigi; i++)
1208                 seq_printf(seq, " %s", ax2asc(buf, &rose_neigh->digipeat->calls[i]));
1209         }
1210 
1211         seq_puts(seq, "\n");
1212     }
1213     return 0;
1214 }
1215 
1216 
1217 const struct seq_operations rose_neigh_seqops = {
1218     .start = rose_neigh_start,
1219     .next = rose_neigh_next,
1220     .stop = rose_neigh_stop,
1221     .show = rose_neigh_show,
1222 };
1223 
1224 static void *rose_route_start(struct seq_file *seq, loff_t *pos)
1225     __acquires(rose_route_list_lock)
1226 {
1227     struct rose_route *rose_route;
1228     int i = 1;
1229 
1230     spin_lock_bh(&rose_route_list_lock);
1231     if (*pos == 0)
1232         return SEQ_START_TOKEN;
1233 
1234     for (rose_route = rose_route_list; rose_route && i < *pos;
1235          rose_route = rose_route->next, ++i);
1236 
1237     return (i == *pos) ? rose_route : NULL;
1238 }
1239 
1240 static void *rose_route_next(struct seq_file *seq, void *v, loff_t *pos)
1241 {
1242     ++*pos;
1243 
1244     return (v == SEQ_START_TOKEN) ? rose_route_list
1245         : ((struct rose_route *)v)->next;
1246 }
1247 
1248 static void rose_route_stop(struct seq_file *seq, void *v)
1249     __releases(rose_route_list_lock)
1250 {
1251     spin_unlock_bh(&rose_route_list_lock);
1252 }
1253 
1254 static int rose_route_show(struct seq_file *seq, void *v)
1255 {
1256     char buf[11], rsbuf[11];
1257 
1258     if (v == SEQ_START_TOKEN)
1259         seq_puts(seq,
1260              "lci  address     callsign   neigh  <-> lci  address     callsign   neigh\n");
1261     else {
1262         struct rose_route *rose_route = v;
1263 
1264         if (rose_route->neigh1)
1265             seq_printf(seq,
1266                    "%3.3X  %-10s  %-9s  %05d      ",
1267                    rose_route->lci1,
1268                    rose2asc(rsbuf, &rose_route->src_addr),
1269                    ax2asc(buf, &rose_route->src_call),
1270                    rose_route->neigh1->number);
1271         else
1272             seq_puts(seq,
1273                  "000  *           *          00000      ");
1274 
1275         if (rose_route->neigh2)
1276             seq_printf(seq,
1277                    "%3.3X  %-10s  %-9s  %05d\n",
1278                    rose_route->lci2,
1279                    rose2asc(rsbuf, &rose_route->dest_addr),
1280                    ax2asc(buf, &rose_route->dest_call),
1281                    rose_route->neigh2->number);
1282          else
1283              seq_puts(seq,
1284                   "000  *           *          00000\n");
1285         }
1286     return 0;
1287 }
1288 
1289 struct seq_operations rose_route_seqops = {
1290     .start = rose_route_start,
1291     .next = rose_route_next,
1292     .stop = rose_route_stop,
1293     .show = rose_route_show,
1294 };
1295 #endif /* CONFIG_PROC_FS */
1296 
1297 /*
1298  *  Release all memory associated with ROSE routing structures.
1299  */
1300 void __exit rose_rt_free(void)
1301 {
1302     struct rose_neigh *s, *rose_neigh = rose_neigh_list;
1303     struct rose_node  *t, *rose_node  = rose_node_list;
1304     struct rose_route *u, *rose_route = rose_route_list;
1305 
1306     while (rose_neigh != NULL) {
1307         s          = rose_neigh;
1308         rose_neigh = rose_neigh->next;
1309 
1310         rose_remove_neigh(s);
1311     }
1312 
1313     while (rose_node != NULL) {
1314         t         = rose_node;
1315         rose_node = rose_node->next;
1316 
1317         rose_remove_node(t);
1318     }
1319 
1320     while (rose_route != NULL) {
1321         u          = rose_route;
1322         rose_route = rose_route->next;
1323 
1324         rose_remove_route(u);
1325     }
1326 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!