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