x25_route.c 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * X.25 Packet Layer release 002
  4. *
  5. * This is ALPHA test software. This code may break your machine,
  6. * randomly fail to work with new releases, misbehave and/or generally
  7. * screw up. It might even work.
  8. *
  9. * This code REQUIRES 2.1.15 or higher
  10. *
  11. * History
  12. * X.25 001 Jonathan Naylor Started coding.
  13. */
  14. #include <linux/if_arp.h>
  15. #include <linux/init.h>
  16. #include <linux/slab.h>
  17. #include <net/x25.h>
  18. LIST_HEAD(x25_route_list);
  19. DEFINE_RWLOCK(x25_route_list_lock);
  20. /*
  21. * Add a new route.
  22. */
  23. static int x25_add_route(struct x25_address *address, unsigned int sigdigits,
  24. struct net_device *dev)
  25. {
  26. struct x25_route *rt;
  27. struct list_head *entry;
  28. int rc = -EINVAL;
  29. write_lock_bh(&x25_route_list_lock);
  30. list_for_each(entry, &x25_route_list) {
  31. rt = list_entry(entry, struct x25_route, node);
  32. if (!memcmp(&rt->address, address, sigdigits) &&
  33. rt->sigdigits == sigdigits)
  34. goto out;
  35. }
  36. rt = kmalloc(sizeof(*rt), GFP_ATOMIC);
  37. rc = -ENOMEM;
  38. if (!rt)
  39. goto out;
  40. strcpy(rt->address.x25_addr, "000000000000000");
  41. memcpy(rt->address.x25_addr, address->x25_addr, sigdigits);
  42. rt->sigdigits = sigdigits;
  43. rt->dev = dev;
  44. refcount_set(&rt->refcnt, 1);
  45. list_add(&rt->node, &x25_route_list);
  46. rc = 0;
  47. out:
  48. write_unlock_bh(&x25_route_list_lock);
  49. return rc;
  50. }
  51. /**
  52. * __x25_remove_route - remove route from x25_route_list
  53. * @rt: route to remove
  54. *
  55. * Remove route from x25_route_list. If it was there.
  56. * Caller must hold x25_route_list_lock.
  57. */
  58. static void __x25_remove_route(struct x25_route *rt)
  59. {
  60. if (rt->node.next) {
  61. list_del(&rt->node);
  62. x25_route_put(rt);
  63. }
  64. }
  65. static int x25_del_route(struct x25_address *address, unsigned int sigdigits,
  66. struct net_device *dev)
  67. {
  68. struct x25_route *rt;
  69. struct list_head *entry;
  70. int rc = -EINVAL;
  71. write_lock_bh(&x25_route_list_lock);
  72. list_for_each(entry, &x25_route_list) {
  73. rt = list_entry(entry, struct x25_route, node);
  74. if (!memcmp(&rt->address, address, sigdigits) &&
  75. rt->sigdigits == sigdigits && rt->dev == dev) {
  76. __x25_remove_route(rt);
  77. rc = 0;
  78. break;
  79. }
  80. }
  81. write_unlock_bh(&x25_route_list_lock);
  82. return rc;
  83. }
  84. /*
  85. * A device has been removed, remove its routes.
  86. */
  87. void x25_route_device_down(struct net_device *dev)
  88. {
  89. struct x25_route *rt;
  90. struct list_head *entry, *tmp;
  91. write_lock_bh(&x25_route_list_lock);
  92. list_for_each_safe(entry, tmp, &x25_route_list) {
  93. rt = list_entry(entry, struct x25_route, node);
  94. if (rt->dev == dev)
  95. __x25_remove_route(rt);
  96. }
  97. write_unlock_bh(&x25_route_list_lock);
  98. /* Remove any related forwarding */
  99. x25_clear_forward_by_dev(dev);
  100. }
  101. /*
  102. * Check that the device given is a valid X.25 interface that is "up".
  103. */
  104. struct net_device *x25_dev_get(char *devname)
  105. {
  106. struct net_device *dev = dev_get_by_name(&init_net, devname);
  107. if (dev &&
  108. (!(dev->flags & IFF_UP) || (dev->type != ARPHRD_X25
  109. #if IS_ENABLED(CONFIG_LLC)
  110. && dev->type != ARPHRD_ETHER
  111. #endif
  112. ))){
  113. dev_put(dev);
  114. dev = NULL;
  115. }
  116. return dev;
  117. }
  118. /**
  119. * x25_get_route - Find a route given an X.25 address.
  120. * @addr: - address to find a route for
  121. *
  122. * Find a route given an X.25 address.
  123. */
  124. struct x25_route *x25_get_route(struct x25_address *addr)
  125. {
  126. struct x25_route *rt, *use = NULL;
  127. struct list_head *entry;
  128. read_lock_bh(&x25_route_list_lock);
  129. list_for_each(entry, &x25_route_list) {
  130. rt = list_entry(entry, struct x25_route, node);
  131. if (!memcmp(&rt->address, addr, rt->sigdigits)) {
  132. if (!use)
  133. use = rt;
  134. else if (rt->sigdigits > use->sigdigits)
  135. use = rt;
  136. }
  137. }
  138. if (use)
  139. x25_route_hold(use);
  140. read_unlock_bh(&x25_route_list_lock);
  141. return use;
  142. }
  143. /*
  144. * Handle the ioctls that control the routing functions.
  145. */
  146. int x25_route_ioctl(unsigned int cmd, void __user *arg)
  147. {
  148. struct x25_route_struct rt;
  149. struct net_device *dev;
  150. int rc = -EINVAL;
  151. if (cmd != SIOCADDRT && cmd != SIOCDELRT)
  152. goto out;
  153. rc = -EFAULT;
  154. if (copy_from_user(&rt, arg, sizeof(rt)))
  155. goto out;
  156. rc = -EINVAL;
  157. if (rt.sigdigits > 15)
  158. goto out;
  159. dev = x25_dev_get(rt.device);
  160. if (!dev)
  161. goto out;
  162. if (cmd == SIOCADDRT)
  163. rc = x25_add_route(&rt.address, rt.sigdigits, dev);
  164. else
  165. rc = x25_del_route(&rt.address, rt.sigdigits, dev);
  166. dev_put(dev);
  167. out:
  168. return rc;
  169. }
  170. /*
  171. * Release all memory associated with X.25 routing structures.
  172. */
  173. void __exit x25_route_free(void)
  174. {
  175. struct x25_route *rt;
  176. struct list_head *entry, *tmp;
  177. write_lock_bh(&x25_route_list_lock);
  178. list_for_each_safe(entry, tmp, &x25_route_list) {
  179. rt = list_entry(entry, struct x25_route, node);
  180. __x25_remove_route(rt);
  181. }
  182. write_unlock_bh(&x25_route_list_lock);
  183. }