rose_route.c 30 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336
  1. /*
  2. * This program is free software; you can redistribute it and/or modify
  3. * it under the terms of the GNU General Public License as published by
  4. * the Free Software Foundation; either version 2 of the License, or
  5. * (at your option) any later version.
  6. *
  7. * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
  8. * Copyright (C) Terry Dawson VK2KTJ (terry@animats.net)
  9. */
  10. #include <linux/errno.h>
  11. #include <linux/types.h>
  12. #include <linux/socket.h>
  13. #include <linux/in.h>
  14. #include <linux/kernel.h>
  15. #include <linux/timer.h>
  16. #include <linux/string.h>
  17. #include <linux/sockios.h>
  18. #include <linux/net.h>
  19. #include <net/ax25.h>
  20. #include <linux/inet.h>
  21. #include <linux/netdevice.h>
  22. #include <net/arp.h>
  23. #include <linux/if_arp.h>
  24. #include <linux/skbuff.h>
  25. #include <net/sock.h>
  26. #include <net/tcp_states.h>
  27. #include <asm/system.h>
  28. #include <asm/uaccess.h>
  29. #include <linux/fcntl.h>
  30. #include <linux/termios.h> /* For TIOCINQ/OUTQ */
  31. #include <linux/mm.h>
  32. #include <linux/interrupt.h>
  33. #include <linux/notifier.h>
  34. #include <linux/netfilter.h>
  35. #include <linux/init.h>
  36. #include <net/rose.h>
  37. #include <linux/seq_file.h>
  38. static unsigned int rose_neigh_no = 1;
  39. static struct rose_node *rose_node_list;
  40. static DEFINE_SPINLOCK(rose_node_list_lock);
  41. static struct rose_neigh *rose_neigh_list;
  42. static DEFINE_SPINLOCK(rose_neigh_list_lock);
  43. static struct rose_route *rose_route_list;
  44. static DEFINE_SPINLOCK(rose_route_list_lock);
  45. struct rose_neigh rose_loopback_neigh;
  46. /*
  47. * Add a new route to a node, and in the process add the node and the
  48. * neighbour if it is new.
  49. */
  50. static int __must_check rose_add_node(struct rose_route_struct *rose_route,
  51. struct net_device *dev)
  52. {
  53. struct rose_node *rose_node, *rose_tmpn, *rose_tmpp;
  54. struct rose_neigh *rose_neigh;
  55. int i, res = 0;
  56. spin_lock_bh(&rose_node_list_lock);
  57. spin_lock_bh(&rose_neigh_list_lock);
  58. rose_node = rose_node_list;
  59. while (rose_node != NULL) {
  60. if ((rose_node->mask == rose_route->mask) &&
  61. (rosecmpm(&rose_route->address, &rose_node->address,
  62. rose_route->mask) == 0))
  63. break;
  64. rose_node = rose_node->next;
  65. }
  66. if (rose_node != NULL && rose_node->loopback) {
  67. res = -EINVAL;
  68. goto out;
  69. }
  70. rose_neigh = rose_neigh_list;
  71. while (rose_neigh != NULL) {
  72. if (ax25cmp(&rose_route->neighbour, &rose_neigh->callsign) == 0
  73. && rose_neigh->dev == dev)
  74. break;
  75. rose_neigh = rose_neigh->next;
  76. }
  77. if (rose_neigh == NULL) {
  78. rose_neigh = kmalloc(sizeof(*rose_neigh), GFP_ATOMIC);
  79. if (rose_neigh == NULL) {
  80. res = -ENOMEM;
  81. goto out;
  82. }
  83. rose_neigh->callsign = rose_route->neighbour;
  84. rose_neigh->digipeat = NULL;
  85. rose_neigh->ax25 = NULL;
  86. rose_neigh->dev = dev;
  87. rose_neigh->count = 0;
  88. rose_neigh->use = 0;
  89. rose_neigh->dce_mode = 0;
  90. rose_neigh->loopback = 0;
  91. rose_neigh->number = rose_neigh_no++;
  92. rose_neigh->restarted = 0;
  93. skb_queue_head_init(&rose_neigh->queue);
  94. init_timer(&rose_neigh->ftimer);
  95. init_timer(&rose_neigh->t0timer);
  96. if (rose_route->ndigis != 0) {
  97. if ((rose_neigh->digipeat = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
  98. kfree(rose_neigh);
  99. res = -ENOMEM;
  100. goto out;
  101. }
  102. rose_neigh->digipeat->ndigi = rose_route->ndigis;
  103. rose_neigh->digipeat->lastrepeat = -1;
  104. for (i = 0; i < rose_route->ndigis; i++) {
  105. rose_neigh->digipeat->calls[i] =
  106. rose_route->digipeaters[i];
  107. rose_neigh->digipeat->repeated[i] = 0;
  108. }
  109. }
  110. rose_neigh->next = rose_neigh_list;
  111. rose_neigh_list = rose_neigh;
  112. }
  113. /*
  114. * This is a new node to be inserted into the list. Find where it needs
  115. * to be inserted into the list, and insert it. We want to be sure
  116. * to order the list in descending order of mask size to ensure that
  117. * later when we are searching this list the first match will be the
  118. * best match.
  119. */
  120. if (rose_node == NULL) {
  121. rose_tmpn = rose_node_list;
  122. rose_tmpp = NULL;
  123. while (rose_tmpn != NULL) {
  124. if (rose_tmpn->mask > rose_route->mask) {
  125. rose_tmpp = rose_tmpn;
  126. rose_tmpn = rose_tmpn->next;
  127. } else {
  128. break;
  129. }
  130. }
  131. /* create new node */
  132. rose_node = kmalloc(sizeof(*rose_node), GFP_ATOMIC);
  133. if (rose_node == NULL) {
  134. res = -ENOMEM;
  135. goto out;
  136. }
  137. rose_node->address = rose_route->address;
  138. rose_node->mask = rose_route->mask;
  139. rose_node->count = 1;
  140. rose_node->loopback = 0;
  141. rose_node->neighbour[0] = rose_neigh;
  142. if (rose_tmpn == NULL) {
  143. if (rose_tmpp == NULL) { /* Empty list */
  144. rose_node_list = rose_node;
  145. rose_node->next = NULL;
  146. } else {
  147. rose_tmpp->next = rose_node;
  148. rose_node->next = NULL;
  149. }
  150. } else {
  151. if (rose_tmpp == NULL) { /* 1st node */
  152. rose_node->next = rose_node_list;
  153. rose_node_list = rose_node;
  154. } else {
  155. rose_tmpp->next = rose_node;
  156. rose_node->next = rose_tmpn;
  157. }
  158. }
  159. rose_neigh->count++;
  160. goto out;
  161. }
  162. /* We have space, slot it in */
  163. if (rose_node->count < 3) {
  164. rose_node->neighbour[rose_node->count] = rose_neigh;
  165. rose_node->count++;
  166. rose_neigh->count++;
  167. }
  168. out:
  169. spin_unlock_bh(&rose_neigh_list_lock);
  170. spin_unlock_bh(&rose_node_list_lock);
  171. return res;
  172. }
  173. /*
  174. * Caller is holding rose_node_list_lock.
  175. */
  176. static void rose_remove_node(struct rose_node *rose_node)
  177. {
  178. struct rose_node *s;
  179. if ((s = rose_node_list) == rose_node) {
  180. rose_node_list = rose_node->next;
  181. kfree(rose_node);
  182. return;
  183. }
  184. while (s != NULL && s->next != NULL) {
  185. if (s->next == rose_node) {
  186. s->next = rose_node->next;
  187. kfree(rose_node);
  188. return;
  189. }
  190. s = s->next;
  191. }
  192. }
  193. /*
  194. * Caller is holding rose_neigh_list_lock.
  195. */
  196. static void rose_remove_neigh(struct rose_neigh *rose_neigh)
  197. {
  198. struct rose_neigh *s;
  199. rose_stop_ftimer(rose_neigh);
  200. rose_stop_t0timer(rose_neigh);
  201. skb_queue_purge(&rose_neigh->queue);
  202. if ((s = rose_neigh_list) == rose_neigh) {
  203. rose_neigh_list = rose_neigh->next;
  204. kfree(rose_neigh->digipeat);
  205. kfree(rose_neigh);
  206. return;
  207. }
  208. while (s != NULL && s->next != NULL) {
  209. if (s->next == rose_neigh) {
  210. s->next = rose_neigh->next;
  211. kfree(rose_neigh->digipeat);
  212. kfree(rose_neigh);
  213. return;
  214. }
  215. s = s->next;
  216. }
  217. }
  218. /*
  219. * Caller is holding rose_route_list_lock.
  220. */
  221. static void rose_remove_route(struct rose_route *rose_route)
  222. {
  223. struct rose_route *s;
  224. if (rose_route->neigh1 != NULL)
  225. rose_route->neigh1->use--;
  226. if (rose_route->neigh2 != NULL)
  227. rose_route->neigh2->use--;
  228. if ((s = rose_route_list) == rose_route) {
  229. rose_route_list = rose_route->next;
  230. kfree(rose_route);
  231. return;
  232. }
  233. while (s != NULL && s->next != NULL) {
  234. if (s->next == rose_route) {
  235. s->next = rose_route->next;
  236. kfree(rose_route);
  237. return;
  238. }
  239. s = s->next;
  240. }
  241. }
  242. /*
  243. * "Delete" a node. Strictly speaking remove a route to a node. The node
  244. * is only deleted if no routes are left to it.
  245. */
  246. static int rose_del_node(struct rose_route_struct *rose_route,
  247. struct net_device *dev)
  248. {
  249. struct rose_node *rose_node;
  250. struct rose_neigh *rose_neigh;
  251. int i, err = 0;
  252. spin_lock_bh(&rose_node_list_lock);
  253. spin_lock_bh(&rose_neigh_list_lock);
  254. rose_node = rose_node_list;
  255. while (rose_node != NULL) {
  256. if ((rose_node->mask == rose_route->mask) &&
  257. (rosecmpm(&rose_route->address, &rose_node->address,
  258. rose_route->mask) == 0))
  259. break;
  260. rose_node = rose_node->next;
  261. }
  262. if (rose_node == NULL || rose_node->loopback) {
  263. err = -EINVAL;
  264. goto out;
  265. }
  266. rose_neigh = rose_neigh_list;
  267. while (rose_neigh != NULL) {
  268. if (ax25cmp(&rose_route->neighbour, &rose_neigh->callsign) == 0
  269. && rose_neigh->dev == dev)
  270. break;
  271. rose_neigh = rose_neigh->next;
  272. }
  273. if (rose_neigh == NULL) {
  274. err = -EINVAL;
  275. goto out;
  276. }
  277. for (i = 0; i < rose_node->count; i++) {
  278. if (rose_node->neighbour[i] == rose_neigh) {
  279. rose_neigh->count--;
  280. if (rose_neigh->count == 0 && rose_neigh->use == 0)
  281. rose_remove_neigh(rose_neigh);
  282. rose_node->count--;
  283. if (rose_node->count == 0) {
  284. rose_remove_node(rose_node);
  285. } else {
  286. switch (i) {
  287. case 0:
  288. rose_node->neighbour[0] =
  289. rose_node->neighbour[1];
  290. case 1:
  291. rose_node->neighbour[1] =
  292. rose_node->neighbour[2];
  293. case 2:
  294. break;
  295. }
  296. }
  297. goto out;
  298. }
  299. }
  300. err = -EINVAL;
  301. out:
  302. spin_unlock_bh(&rose_neigh_list_lock);
  303. spin_unlock_bh(&rose_node_list_lock);
  304. return err;
  305. }
  306. /*
  307. * Add the loopback neighbour.
  308. */
  309. void rose_add_loopback_neigh(void)
  310. {
  311. struct rose_neigh *sn = &rose_loopback_neigh;
  312. sn->callsign = null_ax25_address;
  313. sn->digipeat = NULL;
  314. sn->ax25 = NULL;
  315. sn->dev = NULL;
  316. sn->count = 0;
  317. sn->use = 0;
  318. sn->dce_mode = 1;
  319. sn->loopback = 1;
  320. sn->number = rose_neigh_no++;
  321. sn->restarted = 1;
  322. skb_queue_head_init(&sn->queue);
  323. init_timer(&sn->ftimer);
  324. init_timer(&sn->t0timer);
  325. spin_lock_bh(&rose_neigh_list_lock);
  326. sn->next = rose_neigh_list;
  327. rose_neigh_list = sn;
  328. spin_unlock_bh(&rose_neigh_list_lock);
  329. }
  330. /*
  331. * Add a loopback node.
  332. */
  333. int rose_add_loopback_node(rose_address *address)
  334. {
  335. struct rose_node *rose_node;
  336. int err = 0;
  337. spin_lock_bh(&rose_node_list_lock);
  338. rose_node = rose_node_list;
  339. while (rose_node != NULL) {
  340. if ((rose_node->mask == 10) &&
  341. (rosecmpm(address, &rose_node->address, 10) == 0) &&
  342. rose_node->loopback)
  343. break;
  344. rose_node = rose_node->next;
  345. }
  346. if (rose_node != NULL)
  347. goto out;
  348. if ((rose_node = kmalloc(sizeof(*rose_node), GFP_ATOMIC)) == NULL) {
  349. err = -ENOMEM;
  350. goto out;
  351. }
  352. rose_node->address = *address;
  353. rose_node->mask = 10;
  354. rose_node->count = 1;
  355. rose_node->loopback = 1;
  356. rose_node->neighbour[0] = &rose_loopback_neigh;
  357. /* Insert at the head of list. Address is always mask=10 */
  358. rose_node->next = rose_node_list;
  359. rose_node_list = rose_node;
  360. rose_loopback_neigh.count++;
  361. out:
  362. spin_unlock_bh(&rose_node_list_lock);
  363. return err;
  364. }
  365. /*
  366. * Delete a loopback node.
  367. */
  368. void rose_del_loopback_node(rose_address *address)
  369. {
  370. struct rose_node *rose_node;
  371. spin_lock_bh(&rose_node_list_lock);
  372. rose_node = rose_node_list;
  373. while (rose_node != NULL) {
  374. if ((rose_node->mask == 10) &&
  375. (rosecmpm(address, &rose_node->address, 10) == 0) &&
  376. rose_node->loopback)
  377. break;
  378. rose_node = rose_node->next;
  379. }
  380. if (rose_node == NULL)
  381. goto out;
  382. rose_remove_node(rose_node);
  383. rose_loopback_neigh.count--;
  384. out:
  385. spin_unlock_bh(&rose_node_list_lock);
  386. }
  387. /*
  388. * A device has been removed. Remove its routes and neighbours.
  389. */
  390. void rose_rt_device_down(struct net_device *dev)
  391. {
  392. struct rose_neigh *s, *rose_neigh;
  393. struct rose_node *t, *rose_node;
  394. int i;
  395. spin_lock_bh(&rose_node_list_lock);
  396. spin_lock_bh(&rose_neigh_list_lock);
  397. rose_neigh = rose_neigh_list;
  398. while (rose_neigh != NULL) {
  399. s = rose_neigh;
  400. rose_neigh = rose_neigh->next;
  401. if (s->dev != dev)
  402. continue;
  403. rose_node = rose_node_list;
  404. while (rose_node != NULL) {
  405. t = rose_node;
  406. rose_node = rose_node->next;
  407. for (i = 0; i < t->count; i++) {
  408. if (t->neighbour[i] != s)
  409. continue;
  410. t->count--;
  411. switch (i) {
  412. case 0:
  413. t->neighbour[0] = t->neighbour[1];
  414. case 1:
  415. t->neighbour[1] = t->neighbour[2];
  416. case 2:
  417. break;
  418. }
  419. }
  420. if (t->count <= 0)
  421. rose_remove_node(t);
  422. }
  423. rose_remove_neigh(s);
  424. }
  425. spin_unlock_bh(&rose_neigh_list_lock);
  426. spin_unlock_bh(&rose_node_list_lock);
  427. }
  428. #if 0 /* Currently unused */
  429. /*
  430. * A device has been removed. Remove its links.
  431. */
  432. void rose_route_device_down(struct net_device *dev)
  433. {
  434. struct rose_route *s, *rose_route;
  435. spin_lock_bh(&rose_route_list_lock);
  436. rose_route = rose_route_list;
  437. while (rose_route != NULL) {
  438. s = rose_route;
  439. rose_route = rose_route->next;
  440. if (s->neigh1->dev == dev || s->neigh2->dev == dev)
  441. rose_remove_route(s);
  442. }
  443. spin_unlock_bh(&rose_route_list_lock);
  444. }
  445. #endif
  446. /*
  447. * Clear all nodes and neighbours out, except for neighbours with
  448. * active connections going through them.
  449. * Do not clear loopback neighbour and nodes.
  450. */
  451. static int rose_clear_routes(void)
  452. {
  453. struct rose_neigh *s, *rose_neigh;
  454. struct rose_node *t, *rose_node;
  455. spin_lock_bh(&rose_node_list_lock);
  456. spin_lock_bh(&rose_neigh_list_lock);
  457. rose_neigh = rose_neigh_list;
  458. rose_node = rose_node_list;
  459. while (rose_node != NULL) {
  460. t = rose_node;
  461. rose_node = rose_node->next;
  462. if (!t->loopback)
  463. rose_remove_node(t);
  464. }
  465. while (rose_neigh != NULL) {
  466. s = rose_neigh;
  467. rose_neigh = rose_neigh->next;
  468. if (s->use == 0 && !s->loopback) {
  469. s->count = 0;
  470. rose_remove_neigh(s);
  471. }
  472. }
  473. spin_unlock_bh(&rose_neigh_list_lock);
  474. spin_unlock_bh(&rose_node_list_lock);
  475. return 0;
  476. }
  477. /*
  478. * Check that the device given is a valid AX.25 interface that is "up".
  479. */
  480. static struct net_device *rose_ax25_dev_get(char *devname)
  481. {
  482. struct net_device *dev;
  483. if ((dev = dev_get_by_name(devname)) == NULL)
  484. return NULL;
  485. if ((dev->flags & IFF_UP) && dev->type == ARPHRD_AX25)
  486. return dev;
  487. dev_put(dev);
  488. return NULL;
  489. }
  490. /*
  491. * Find the first active ROSE device, usually "rose0".
  492. */
  493. struct net_device *rose_dev_first(void)
  494. {
  495. struct net_device *dev, *first = NULL;
  496. read_lock(&dev_base_lock);
  497. for (dev = dev_base; dev != NULL; dev = dev->next) {
  498. if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE)
  499. if (first == NULL || strncmp(dev->name, first->name, 3) < 0)
  500. first = dev;
  501. }
  502. read_unlock(&dev_base_lock);
  503. return first;
  504. }
  505. /*
  506. * Find the ROSE device for the given address.
  507. */
  508. struct net_device *rose_dev_get(rose_address *addr)
  509. {
  510. struct net_device *dev;
  511. read_lock(&dev_base_lock);
  512. for (dev = dev_base; dev != NULL; dev = dev->next) {
  513. if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE && rosecmp(addr, (rose_address *)dev->dev_addr) == 0) {
  514. dev_hold(dev);
  515. goto out;
  516. }
  517. }
  518. out:
  519. read_unlock(&dev_base_lock);
  520. return dev;
  521. }
  522. static int rose_dev_exists(rose_address *addr)
  523. {
  524. struct net_device *dev;
  525. read_lock(&dev_base_lock);
  526. for (dev = dev_base; dev != NULL; dev = dev->next) {
  527. if ((dev->flags & IFF_UP) && dev->type == ARPHRD_ROSE && rosecmp(addr, (rose_address *)dev->dev_addr) == 0)
  528. goto out;
  529. }
  530. out:
  531. read_unlock(&dev_base_lock);
  532. return dev != NULL;
  533. }
  534. struct rose_route *rose_route_free_lci(unsigned int lci, struct rose_neigh *neigh)
  535. {
  536. struct rose_route *rose_route;
  537. for (rose_route = rose_route_list; rose_route != NULL; rose_route = rose_route->next)
  538. if ((rose_route->neigh1 == neigh && rose_route->lci1 == lci) ||
  539. (rose_route->neigh2 == neigh && rose_route->lci2 == lci))
  540. return rose_route;
  541. return NULL;
  542. }
  543. /*
  544. * Find a neighbour given a ROSE address.
  545. */
  546. struct rose_neigh *rose_get_neigh(rose_address *addr, unsigned char *cause,
  547. unsigned char *diagnostic)
  548. {
  549. struct rose_neigh *res = NULL;
  550. struct rose_node *node;
  551. int failed = 0;
  552. int i;
  553. spin_lock_bh(&rose_node_list_lock);
  554. for (node = rose_node_list; node != NULL; node = node->next) {
  555. if (rosecmpm(addr, &node->address, node->mask) == 0) {
  556. for (i = 0; i < node->count; i++) {
  557. if (!rose_ftimer_running(node->neighbour[i])) {
  558. res = node->neighbour[i];
  559. goto out;
  560. } else
  561. failed = 1;
  562. }
  563. break;
  564. }
  565. }
  566. if (failed) {
  567. *cause = ROSE_OUT_OF_ORDER;
  568. *diagnostic = 0;
  569. } else {
  570. *cause = ROSE_NOT_OBTAINABLE;
  571. *diagnostic = 0;
  572. }
  573. out:
  574. spin_unlock_bh(&rose_node_list_lock);
  575. return res;
  576. }
  577. /*
  578. * Handle the ioctls that control the routing functions.
  579. */
  580. int rose_rt_ioctl(unsigned int cmd, void __user *arg)
  581. {
  582. struct rose_route_struct rose_route;
  583. struct net_device *dev;
  584. int err;
  585. switch (cmd) {
  586. case SIOCADDRT:
  587. if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
  588. return -EFAULT;
  589. if ((dev = rose_ax25_dev_get(rose_route.device)) == NULL)
  590. return -EINVAL;
  591. if (rose_dev_exists(&rose_route.address)) { /* Can't add routes to ourself */
  592. dev_put(dev);
  593. return -EINVAL;
  594. }
  595. if (rose_route.mask > 10) /* Mask can't be more than 10 digits */
  596. return -EINVAL;
  597. if (rose_route.ndigis > AX25_MAX_DIGIS)
  598. return -EINVAL;
  599. err = rose_add_node(&rose_route, dev);
  600. dev_put(dev);
  601. return err;
  602. case SIOCDELRT:
  603. if (copy_from_user(&rose_route, arg, sizeof(struct rose_route_struct)))
  604. return -EFAULT;
  605. if ((dev = rose_ax25_dev_get(rose_route.device)) == NULL)
  606. return -EINVAL;
  607. err = rose_del_node(&rose_route, dev);
  608. dev_put(dev);
  609. return err;
  610. case SIOCRSCLRRT:
  611. return rose_clear_routes();
  612. default:
  613. return -EINVAL;
  614. }
  615. return 0;
  616. }
  617. static void rose_del_route_by_neigh(struct rose_neigh *rose_neigh)
  618. {
  619. struct rose_route *rose_route, *s;
  620. rose_neigh->restarted = 0;
  621. rose_stop_t0timer(rose_neigh);
  622. rose_start_ftimer(rose_neigh);
  623. skb_queue_purge(&rose_neigh->queue);
  624. spin_lock_bh(&rose_route_list_lock);
  625. rose_route = rose_route_list;
  626. while (rose_route != NULL) {
  627. if ((rose_route->neigh1 == rose_neigh && rose_route->neigh2 == rose_neigh) ||
  628. (rose_route->neigh1 == rose_neigh && rose_route->neigh2 == NULL) ||
  629. (rose_route->neigh2 == rose_neigh && rose_route->neigh1 == NULL)) {
  630. s = rose_route->next;
  631. rose_remove_route(rose_route);
  632. rose_route = s;
  633. continue;
  634. }
  635. if (rose_route->neigh1 == rose_neigh) {
  636. rose_route->neigh1->use--;
  637. rose_route->neigh1 = NULL;
  638. rose_transmit_clear_request(rose_route->neigh2, rose_route->lci2, ROSE_OUT_OF_ORDER, 0);
  639. }
  640. if (rose_route->neigh2 == rose_neigh) {
  641. rose_route->neigh2->use--;
  642. rose_route->neigh2 = NULL;
  643. rose_transmit_clear_request(rose_route->neigh1, rose_route->lci1, ROSE_OUT_OF_ORDER, 0);
  644. }
  645. rose_route = rose_route->next;
  646. }
  647. spin_unlock_bh(&rose_route_list_lock);
  648. }
  649. /*
  650. * A level 2 link has timed out, therefore it appears to be a poor link,
  651. * then don't use that neighbour until it is reset. Blow away all through
  652. * routes and connections using this route.
  653. */
  654. void rose_link_failed(ax25_cb *ax25, int reason)
  655. {
  656. struct rose_neigh *rose_neigh;
  657. spin_lock_bh(&rose_neigh_list_lock);
  658. rose_neigh = rose_neigh_list;
  659. while (rose_neigh != NULL) {
  660. if (rose_neigh->ax25 == ax25)
  661. break;
  662. rose_neigh = rose_neigh->next;
  663. }
  664. if (rose_neigh != NULL) {
  665. rose_neigh->ax25 = NULL;
  666. rose_del_route_by_neigh(rose_neigh);
  667. rose_kill_by_neigh(rose_neigh);
  668. }
  669. spin_unlock_bh(&rose_neigh_list_lock);
  670. }
  671. /*
  672. * A device has been "downed" remove its link status. Blow away all
  673. * through routes and connections that use this device.
  674. */
  675. void rose_link_device_down(struct net_device *dev)
  676. {
  677. struct rose_neigh *rose_neigh;
  678. for (rose_neigh = rose_neigh_list; rose_neigh != NULL; rose_neigh = rose_neigh->next) {
  679. if (rose_neigh->dev == dev) {
  680. rose_del_route_by_neigh(rose_neigh);
  681. rose_kill_by_neigh(rose_neigh);
  682. }
  683. }
  684. }
  685. /*
  686. * Route a frame to an appropriate AX.25 connection.
  687. */
  688. int rose_route_frame(struct sk_buff *skb, ax25_cb *ax25)
  689. {
  690. struct rose_neigh *rose_neigh, *new_neigh;
  691. struct rose_route *rose_route;
  692. struct rose_facilities_struct facilities;
  693. rose_address *src_addr, *dest_addr;
  694. struct sock *sk;
  695. unsigned short frametype;
  696. unsigned int lci, new_lci;
  697. unsigned char cause, diagnostic;
  698. struct net_device *dev;
  699. int len, res = 0;
  700. char buf[11];
  701. #if 0
  702. if (call_in_firewall(PF_ROSE, skb->dev, skb->data, NULL, &skb) != FW_ACCEPT)
  703. return res;
  704. #endif
  705. frametype = skb->data[2];
  706. lci = ((skb->data[0] << 8) & 0xF00) + ((skb->data[1] << 0) & 0x0FF);
  707. src_addr = (rose_address *)(skb->data + 9);
  708. dest_addr = (rose_address *)(skb->data + 4);
  709. spin_lock_bh(&rose_node_list_lock);
  710. spin_lock_bh(&rose_neigh_list_lock);
  711. spin_lock_bh(&rose_route_list_lock);
  712. rose_neigh = rose_neigh_list;
  713. while (rose_neigh != NULL) {
  714. if (ax25cmp(&ax25->dest_addr, &rose_neigh->callsign) == 0 &&
  715. ax25->ax25_dev->dev == rose_neigh->dev)
  716. break;
  717. rose_neigh = rose_neigh->next;
  718. }
  719. if (rose_neigh == NULL) {
  720. printk("rose_route : unknown neighbour or device %s\n",
  721. ax2asc(buf, &ax25->dest_addr));
  722. goto out;
  723. }
  724. /*
  725. * Obviously the link is working, halt the ftimer.
  726. */
  727. rose_stop_ftimer(rose_neigh);
  728. /*
  729. * LCI of zero is always for us, and its always a restart
  730. * frame.
  731. */
  732. if (lci == 0) {
  733. rose_link_rx_restart(skb, rose_neigh, frametype);
  734. goto out;
  735. }
  736. /*
  737. * Find an existing socket.
  738. */
  739. if ((sk = rose_find_socket(lci, rose_neigh)) != NULL) {
  740. if (frametype == ROSE_CALL_REQUEST) {
  741. struct rose_sock *rose = rose_sk(sk);
  742. /* Remove an existing unused socket */
  743. rose_clear_queues(sk);
  744. rose->cause = ROSE_NETWORK_CONGESTION;
  745. rose->diagnostic = 0;
  746. rose->neighbour->use--;
  747. rose->neighbour = NULL;
  748. rose->lci = 0;
  749. rose->state = ROSE_STATE_0;
  750. sk->sk_state = TCP_CLOSE;
  751. sk->sk_err = 0;
  752. sk->sk_shutdown |= SEND_SHUTDOWN;
  753. if (!sock_flag(sk, SOCK_DEAD)) {
  754. sk->sk_state_change(sk);
  755. sock_set_flag(sk, SOCK_DEAD);
  756. }
  757. }
  758. else {
  759. skb->h.raw = skb->data;
  760. res = rose_process_rx_frame(sk, skb);
  761. goto out;
  762. }
  763. }
  764. /*
  765. * Is is a Call Request and is it for us ?
  766. */
  767. if (frametype == ROSE_CALL_REQUEST)
  768. if ((dev = rose_dev_get(dest_addr)) != NULL) {
  769. res = rose_rx_call_request(skb, dev, rose_neigh, lci);
  770. dev_put(dev);
  771. goto out;
  772. }
  773. if (!sysctl_rose_routing_control) {
  774. rose_transmit_clear_request(rose_neigh, lci, ROSE_NOT_OBTAINABLE, 0);
  775. goto out;
  776. }
  777. /*
  778. * Route it to the next in line if we have an entry for it.
  779. */
  780. rose_route = rose_route_list;
  781. while (rose_route != NULL) {
  782. if (rose_route->lci1 == lci &&
  783. rose_route->neigh1 == rose_neigh) {
  784. if (frametype == ROSE_CALL_REQUEST) {
  785. /* F6FBB - Remove an existing unused route */
  786. rose_remove_route(rose_route);
  787. break;
  788. } else if (rose_route->neigh2 != NULL) {
  789. skb->data[0] &= 0xF0;
  790. skb->data[0] |= (rose_route->lci2 >> 8) & 0x0F;
  791. skb->data[1] = (rose_route->lci2 >> 0) & 0xFF;
  792. rose_transmit_link(skb, rose_route->neigh2);
  793. if (frametype == ROSE_CLEAR_CONFIRMATION)
  794. rose_remove_route(rose_route);
  795. res = 1;
  796. goto out;
  797. } else {
  798. if (frametype == ROSE_CLEAR_CONFIRMATION)
  799. rose_remove_route(rose_route);
  800. goto out;
  801. }
  802. }
  803. if (rose_route->lci2 == lci &&
  804. rose_route->neigh2 == rose_neigh) {
  805. if (frametype == ROSE_CALL_REQUEST) {
  806. /* F6FBB - Remove an existing unused route */
  807. rose_remove_route(rose_route);
  808. break;
  809. } else if (rose_route->neigh1 != NULL) {
  810. skb->data[0] &= 0xF0;
  811. skb->data[0] |= (rose_route->lci1 >> 8) & 0x0F;
  812. skb->data[1] = (rose_route->lci1 >> 0) & 0xFF;
  813. rose_transmit_link(skb, rose_route->neigh1);
  814. if (frametype == ROSE_CLEAR_CONFIRMATION)
  815. rose_remove_route(rose_route);
  816. res = 1;
  817. goto out;
  818. } else {
  819. if (frametype == ROSE_CLEAR_CONFIRMATION)
  820. rose_remove_route(rose_route);
  821. goto out;
  822. }
  823. }
  824. rose_route = rose_route->next;
  825. }
  826. /*
  827. * We know that:
  828. * 1. The frame isn't for us,
  829. * 2. It isn't "owned" by any existing route.
  830. */
  831. if (frametype != ROSE_CALL_REQUEST) { /* XXX */
  832. res = 0;
  833. goto out;
  834. }
  835. len = (((skb->data[3] >> 4) & 0x0F) + 1) / 2;
  836. len += (((skb->data[3] >> 0) & 0x0F) + 1) / 2;
  837. memset(&facilities, 0x00, sizeof(struct rose_facilities_struct));
  838. if (!rose_parse_facilities(skb->data + len + 4, &facilities)) {
  839. rose_transmit_clear_request(rose_neigh, lci, ROSE_INVALID_FACILITY, 76);
  840. goto out;
  841. }
  842. /*
  843. * Check for routing loops.
  844. */
  845. rose_route = rose_route_list;
  846. while (rose_route != NULL) {
  847. if (rose_route->rand == facilities.rand &&
  848. rosecmp(src_addr, &rose_route->src_addr) == 0 &&
  849. ax25cmp(&facilities.dest_call, &rose_route->src_call) == 0 &&
  850. ax25cmp(&facilities.source_call, &rose_route->dest_call) == 0) {
  851. rose_transmit_clear_request(rose_neigh, lci, ROSE_NOT_OBTAINABLE, 120);
  852. goto out;
  853. }
  854. rose_route = rose_route->next;
  855. }
  856. if ((new_neigh = rose_get_neigh(dest_addr, &cause, &diagnostic)) == NULL) {
  857. rose_transmit_clear_request(rose_neigh, lci, cause, diagnostic);
  858. goto out;
  859. }
  860. if ((new_lci = rose_new_lci(new_neigh)) == 0) {
  861. rose_transmit_clear_request(rose_neigh, lci, ROSE_NETWORK_CONGESTION, 71);
  862. goto out;
  863. }
  864. if ((rose_route = kmalloc(sizeof(*rose_route), GFP_ATOMIC)) == NULL) {
  865. rose_transmit_clear_request(rose_neigh, lci, ROSE_NETWORK_CONGESTION, 120);
  866. goto out;
  867. }
  868. rose_route->lci1 = lci;
  869. rose_route->src_addr = *src_addr;
  870. rose_route->dest_addr = *dest_addr;
  871. rose_route->src_call = facilities.dest_call;
  872. rose_route->dest_call = facilities.source_call;
  873. rose_route->rand = facilities.rand;
  874. rose_route->neigh1 = rose_neigh;
  875. rose_route->lci2 = new_lci;
  876. rose_route->neigh2 = new_neigh;
  877. rose_route->neigh1->use++;
  878. rose_route->neigh2->use++;
  879. rose_route->next = rose_route_list;
  880. rose_route_list = rose_route;
  881. skb->data[0] &= 0xF0;
  882. skb->data[0] |= (rose_route->lci2 >> 8) & 0x0F;
  883. skb->data[1] = (rose_route->lci2 >> 0) & 0xFF;
  884. rose_transmit_link(skb, rose_route->neigh2);
  885. res = 1;
  886. out:
  887. spin_unlock_bh(&rose_route_list_lock);
  888. spin_unlock_bh(&rose_neigh_list_lock);
  889. spin_unlock_bh(&rose_node_list_lock);
  890. return res;
  891. }
  892. #ifdef CONFIG_PROC_FS
  893. static void *rose_node_start(struct seq_file *seq, loff_t *pos)
  894. {
  895. struct rose_node *rose_node;
  896. int i = 1;
  897. spin_lock_bh(&rose_neigh_list_lock);
  898. if (*pos == 0)
  899. return SEQ_START_TOKEN;
  900. for (rose_node = rose_node_list; rose_node && i < *pos;
  901. rose_node = rose_node->next, ++i);
  902. return (i == *pos) ? rose_node : NULL;
  903. }
  904. static void *rose_node_next(struct seq_file *seq, void *v, loff_t *pos)
  905. {
  906. ++*pos;
  907. return (v == SEQ_START_TOKEN) ? rose_node_list
  908. : ((struct rose_node *)v)->next;
  909. }
  910. static void rose_node_stop(struct seq_file *seq, void *v)
  911. {
  912. spin_unlock_bh(&rose_neigh_list_lock);
  913. }
  914. static int rose_node_show(struct seq_file *seq, void *v)
  915. {
  916. int i;
  917. if (v == SEQ_START_TOKEN)
  918. seq_puts(seq, "address mask n neigh neigh neigh\n");
  919. else {
  920. const struct rose_node *rose_node = v;
  921. /* if (rose_node->loopback) {
  922. seq_printf(seq, "%-10s %04d 1 loopback\n",
  923. rose2asc(&rose_node->address),
  924. rose_node->mask);
  925. } else { */
  926. seq_printf(seq, "%-10s %04d %d",
  927. rose2asc(&rose_node->address),
  928. rose_node->mask,
  929. rose_node->count);
  930. for (i = 0; i < rose_node->count; i++)
  931. seq_printf(seq, " %05d",
  932. rose_node->neighbour[i]->number);
  933. seq_puts(seq, "\n");
  934. /* } */
  935. }
  936. return 0;
  937. }
  938. static struct seq_operations rose_node_seqops = {
  939. .start = rose_node_start,
  940. .next = rose_node_next,
  941. .stop = rose_node_stop,
  942. .show = rose_node_show,
  943. };
  944. static int rose_nodes_open(struct inode *inode, struct file *file)
  945. {
  946. return seq_open(file, &rose_node_seqops);
  947. }
  948. const struct file_operations rose_nodes_fops = {
  949. .owner = THIS_MODULE,
  950. .open = rose_nodes_open,
  951. .read = seq_read,
  952. .llseek = seq_lseek,
  953. .release = seq_release,
  954. };
  955. static void *rose_neigh_start(struct seq_file *seq, loff_t *pos)
  956. {
  957. struct rose_neigh *rose_neigh;
  958. int i = 1;
  959. spin_lock_bh(&rose_neigh_list_lock);
  960. if (*pos == 0)
  961. return SEQ_START_TOKEN;
  962. for (rose_neigh = rose_neigh_list; rose_neigh && i < *pos;
  963. rose_neigh = rose_neigh->next, ++i);
  964. return (i == *pos) ? rose_neigh : NULL;
  965. }
  966. static void *rose_neigh_next(struct seq_file *seq, void *v, loff_t *pos)
  967. {
  968. ++*pos;
  969. return (v == SEQ_START_TOKEN) ? rose_neigh_list
  970. : ((struct rose_neigh *)v)->next;
  971. }
  972. static void rose_neigh_stop(struct seq_file *seq, void *v)
  973. {
  974. spin_unlock_bh(&rose_neigh_list_lock);
  975. }
  976. static int rose_neigh_show(struct seq_file *seq, void *v)
  977. {
  978. char buf[11];
  979. int i;
  980. if (v == SEQ_START_TOKEN)
  981. seq_puts(seq,
  982. "addr callsign dev count use mode restart t0 tf digipeaters\n");
  983. else {
  984. struct rose_neigh *rose_neigh = v;
  985. /* if (!rose_neigh->loopback) { */
  986. seq_printf(seq, "%05d %-9s %-4s %3d %3d %3s %3s %3lu %3lu",
  987. rose_neigh->number,
  988. (rose_neigh->loopback) ? "RSLOOP-0" : ax2asc(buf, &rose_neigh->callsign),
  989. rose_neigh->dev ? rose_neigh->dev->name : "???",
  990. rose_neigh->count,
  991. rose_neigh->use,
  992. (rose_neigh->dce_mode) ? "DCE" : "DTE",
  993. (rose_neigh->restarted) ? "yes" : "no",
  994. ax25_display_timer(&rose_neigh->t0timer) / HZ,
  995. ax25_display_timer(&rose_neigh->ftimer) / HZ);
  996. if (rose_neigh->digipeat != NULL) {
  997. for (i = 0; i < rose_neigh->digipeat->ndigi; i++)
  998. seq_printf(seq, " %s", ax2asc(buf, &rose_neigh->digipeat->calls[i]));
  999. }
  1000. seq_puts(seq, "\n");
  1001. }
  1002. return 0;
  1003. }
  1004. static struct seq_operations rose_neigh_seqops = {
  1005. .start = rose_neigh_start,
  1006. .next = rose_neigh_next,
  1007. .stop = rose_neigh_stop,
  1008. .show = rose_neigh_show,
  1009. };
  1010. static int rose_neigh_open(struct inode *inode, struct file *file)
  1011. {
  1012. return seq_open(file, &rose_neigh_seqops);
  1013. }
  1014. const struct file_operations rose_neigh_fops = {
  1015. .owner = THIS_MODULE,
  1016. .open = rose_neigh_open,
  1017. .read = seq_read,
  1018. .llseek = seq_lseek,
  1019. .release = seq_release,
  1020. };
  1021. static void *rose_route_start(struct seq_file *seq, loff_t *pos)
  1022. {
  1023. struct rose_route *rose_route;
  1024. int i = 1;
  1025. spin_lock_bh(&rose_route_list_lock);
  1026. if (*pos == 0)
  1027. return SEQ_START_TOKEN;
  1028. for (rose_route = rose_route_list; rose_route && i < *pos;
  1029. rose_route = rose_route->next, ++i);
  1030. return (i == *pos) ? rose_route : NULL;
  1031. }
  1032. static void *rose_route_next(struct seq_file *seq, void *v, loff_t *pos)
  1033. {
  1034. ++*pos;
  1035. return (v == SEQ_START_TOKEN) ? rose_route_list
  1036. : ((struct rose_route *)v)->next;
  1037. }
  1038. static void rose_route_stop(struct seq_file *seq, void *v)
  1039. {
  1040. spin_unlock_bh(&rose_route_list_lock);
  1041. }
  1042. static int rose_route_show(struct seq_file *seq, void *v)
  1043. {
  1044. char buf[11];
  1045. if (v == SEQ_START_TOKEN)
  1046. seq_puts(seq,
  1047. "lci address callsign neigh <-> lci address callsign neigh\n");
  1048. else {
  1049. struct rose_route *rose_route = v;
  1050. if (rose_route->neigh1)
  1051. seq_printf(seq,
  1052. "%3.3X %-10s %-9s %05d ",
  1053. rose_route->lci1,
  1054. rose2asc(&rose_route->src_addr),
  1055. ax2asc(buf, &rose_route->src_call),
  1056. rose_route->neigh1->number);
  1057. else
  1058. seq_puts(seq,
  1059. "000 * * 00000 ");
  1060. if (rose_route->neigh2)
  1061. seq_printf(seq,
  1062. "%3.3X %-10s %-9s %05d\n",
  1063. rose_route->lci2,
  1064. rose2asc(&rose_route->dest_addr),
  1065. ax2asc(buf, &rose_route->dest_call),
  1066. rose_route->neigh2->number);
  1067. else
  1068. seq_puts(seq,
  1069. "000 * * 00000\n");
  1070. }
  1071. return 0;
  1072. }
  1073. static struct seq_operations rose_route_seqops = {
  1074. .start = rose_route_start,
  1075. .next = rose_route_next,
  1076. .stop = rose_route_stop,
  1077. .show = rose_route_show,
  1078. };
  1079. static int rose_route_open(struct inode *inode, struct file *file)
  1080. {
  1081. return seq_open(file, &rose_route_seqops);
  1082. }
  1083. const struct file_operations rose_routes_fops = {
  1084. .owner = THIS_MODULE,
  1085. .open = rose_route_open,
  1086. .read = seq_read,
  1087. .llseek = seq_lseek,
  1088. .release = seq_release,
  1089. };
  1090. #endif /* CONFIG_PROC_FS */
  1091. /*
  1092. * Release all memory associated with ROSE routing structures.
  1093. */
  1094. void __exit rose_rt_free(void)
  1095. {
  1096. struct rose_neigh *s, *rose_neigh = rose_neigh_list;
  1097. struct rose_node *t, *rose_node = rose_node_list;
  1098. struct rose_route *u, *rose_route = rose_route_list;
  1099. while (rose_neigh != NULL) {
  1100. s = rose_neigh;
  1101. rose_neigh = rose_neigh->next;
  1102. rose_remove_neigh(s);
  1103. }
  1104. while (rose_node != NULL) {
  1105. t = rose_node;
  1106. rose_node = rose_node->next;
  1107. rose_remove_node(t);
  1108. }
  1109. while (rose_route != NULL) {
  1110. u = rose_route;
  1111. rose_route = rose_route->next;
  1112. rose_remove_route(u);
  1113. }
  1114. }