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