af_rose.c 38 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641
  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) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
  9. * Copyright (C) Terry Dawson VK2KTJ (terry@animats.net)
  10. * Copyright (C) Tomi Manninen OH2BNS (oh2bns@sral.fi)
  11. */
  12. #include <linux/capability.h>
  13. #include <linux/module.h>
  14. #include <linux/moduleparam.h>
  15. #include <linux/init.h>
  16. #include <linux/errno.h>
  17. #include <linux/types.h>
  18. #include <linux/socket.h>
  19. #include <linux/in.h>
  20. #include <linux/kernel.h>
  21. #include <linux/sched.h>
  22. #include <linux/spinlock.h>
  23. #include <linux/timer.h>
  24. #include <linux/string.h>
  25. #include <linux/sockios.h>
  26. #include <linux/net.h>
  27. #include <linux/stat.h>
  28. #include <net/ax25.h>
  29. #include <linux/inet.h>
  30. #include <linux/netdevice.h>
  31. #include <linux/if_arp.h>
  32. #include <linux/skbuff.h>
  33. #include <net/sock.h>
  34. #include <asm/system.h>
  35. #include <asm/uaccess.h>
  36. #include <linux/fcntl.h>
  37. #include <linux/termios.h>
  38. #include <linux/mm.h>
  39. #include <linux/interrupt.h>
  40. #include <linux/notifier.h>
  41. #include <net/rose.h>
  42. #include <linux/proc_fs.h>
  43. #include <linux/seq_file.h>
  44. #include <net/tcp_states.h>
  45. #include <net/ip.h>
  46. #include <net/arp.h>
  47. static int rose_ndevs = 10;
  48. int sysctl_rose_restart_request_timeout = ROSE_DEFAULT_T0;
  49. int sysctl_rose_call_request_timeout = ROSE_DEFAULT_T1;
  50. int sysctl_rose_reset_request_timeout = ROSE_DEFAULT_T2;
  51. int sysctl_rose_clear_request_timeout = ROSE_DEFAULT_T3;
  52. int sysctl_rose_no_activity_timeout = ROSE_DEFAULT_IDLE;
  53. int sysctl_rose_ack_hold_back_timeout = ROSE_DEFAULT_HB;
  54. int sysctl_rose_routing_control = ROSE_DEFAULT_ROUTING;
  55. int sysctl_rose_link_fail_timeout = ROSE_DEFAULT_FAIL_TIMEOUT;
  56. int sysctl_rose_maximum_vcs = ROSE_DEFAULT_MAXVC;
  57. int sysctl_rose_window_size = ROSE_DEFAULT_WINDOW_SIZE;
  58. static HLIST_HEAD(rose_list);
  59. static DEFINE_SPINLOCK(rose_list_lock);
  60. static struct proto_ops rose_proto_ops;
  61. ax25_address rose_callsign;
  62. /*
  63. * ROSE network devices are virtual network devices encapsulating ROSE
  64. * frames into AX.25 which will be sent through an AX.25 device, so form a
  65. * special "super class" of normal net devices; split their locks off into a
  66. * separate class since they always nest.
  67. */
  68. static struct lock_class_key rose_netdev_xmit_lock_key;
  69. /*
  70. * Convert a ROSE address into text.
  71. */
  72. const char *rose2asc(const rose_address *addr)
  73. {
  74. static char buffer[11];
  75. if (addr->rose_addr[0] == 0x00 && addr->rose_addr[1] == 0x00 &&
  76. addr->rose_addr[2] == 0x00 && addr->rose_addr[3] == 0x00 &&
  77. addr->rose_addr[4] == 0x00) {
  78. strcpy(buffer, "*");
  79. } else {
  80. sprintf(buffer, "%02X%02X%02X%02X%02X", addr->rose_addr[0] & 0xFF,
  81. addr->rose_addr[1] & 0xFF,
  82. addr->rose_addr[2] & 0xFF,
  83. addr->rose_addr[3] & 0xFF,
  84. addr->rose_addr[4] & 0xFF);
  85. }
  86. return buffer;
  87. }
  88. /*
  89. * Compare two ROSE addresses, 0 == equal.
  90. */
  91. int rosecmp(rose_address *addr1, rose_address *addr2)
  92. {
  93. int i;
  94. for (i = 0; i < 5; i++)
  95. if (addr1->rose_addr[i] != addr2->rose_addr[i])
  96. return 1;
  97. return 0;
  98. }
  99. /*
  100. * Compare two ROSE addresses for only mask digits, 0 == equal.
  101. */
  102. int rosecmpm(rose_address *addr1, rose_address *addr2, unsigned short mask)
  103. {
  104. int i, j;
  105. if (mask > 10)
  106. return 1;
  107. for (i = 0; i < mask; i++) {
  108. j = i / 2;
  109. if ((i % 2) != 0) {
  110. if ((addr1->rose_addr[j] & 0x0F) != (addr2->rose_addr[j] & 0x0F))
  111. return 1;
  112. } else {
  113. if ((addr1->rose_addr[j] & 0xF0) != (addr2->rose_addr[j] & 0xF0))
  114. return 1;
  115. }
  116. }
  117. return 0;
  118. }
  119. /*
  120. * Socket removal during an interrupt is now safe.
  121. */
  122. static void rose_remove_socket(struct sock *sk)
  123. {
  124. spin_lock_bh(&rose_list_lock);
  125. sk_del_node_init(sk);
  126. spin_unlock_bh(&rose_list_lock);
  127. }
  128. /*
  129. * Kill all bound sockets on a broken link layer connection to a
  130. * particular neighbour.
  131. */
  132. void rose_kill_by_neigh(struct rose_neigh *neigh)
  133. {
  134. struct sock *s;
  135. struct hlist_node *node;
  136. spin_lock_bh(&rose_list_lock);
  137. sk_for_each(s, node, &rose_list) {
  138. struct rose_sock *rose = rose_sk(s);
  139. if (rose->neighbour == neigh) {
  140. rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
  141. rose->neighbour->use--;
  142. rose->neighbour = NULL;
  143. }
  144. }
  145. spin_unlock_bh(&rose_list_lock);
  146. }
  147. /*
  148. * Kill all bound sockets on a dropped device.
  149. */
  150. static void rose_kill_by_device(struct net_device *dev)
  151. {
  152. struct sock *s;
  153. struct hlist_node *node;
  154. spin_lock_bh(&rose_list_lock);
  155. sk_for_each(s, node, &rose_list) {
  156. struct rose_sock *rose = rose_sk(s);
  157. if (rose->device == dev) {
  158. rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
  159. rose->neighbour->use--;
  160. rose->device = NULL;
  161. }
  162. }
  163. spin_unlock_bh(&rose_list_lock);
  164. }
  165. /*
  166. * Handle device status changes.
  167. */
  168. static int rose_device_event(struct notifier_block *this, unsigned long event,
  169. void *ptr)
  170. {
  171. struct net_device *dev = (struct net_device *)ptr;
  172. if (event != NETDEV_DOWN)
  173. return NOTIFY_DONE;
  174. switch (dev->type) {
  175. case ARPHRD_ROSE:
  176. rose_kill_by_device(dev);
  177. break;
  178. case ARPHRD_AX25:
  179. rose_link_device_down(dev);
  180. rose_rt_device_down(dev);
  181. break;
  182. }
  183. return NOTIFY_DONE;
  184. }
  185. /*
  186. * Add a socket to the bound sockets list.
  187. */
  188. static void rose_insert_socket(struct sock *sk)
  189. {
  190. spin_lock_bh(&rose_list_lock);
  191. sk_add_node(sk, &rose_list);
  192. spin_unlock_bh(&rose_list_lock);
  193. }
  194. /*
  195. * Find a socket that wants to accept the Call Request we just
  196. * received.
  197. */
  198. static struct sock *rose_find_listener(rose_address *addr, ax25_address *call)
  199. {
  200. struct sock *s;
  201. struct hlist_node *node;
  202. spin_lock_bh(&rose_list_lock);
  203. sk_for_each(s, node, &rose_list) {
  204. struct rose_sock *rose = rose_sk(s);
  205. if (!rosecmp(&rose->source_addr, addr) &&
  206. !ax25cmp(&rose->source_call, call) &&
  207. !rose->source_ndigis && s->sk_state == TCP_LISTEN)
  208. goto found;
  209. }
  210. sk_for_each(s, node, &rose_list) {
  211. struct rose_sock *rose = rose_sk(s);
  212. if (!rosecmp(&rose->source_addr, addr) &&
  213. !ax25cmp(&rose->source_call, &null_ax25_address) &&
  214. s->sk_state == TCP_LISTEN)
  215. goto found;
  216. }
  217. s = NULL;
  218. found:
  219. spin_unlock_bh(&rose_list_lock);
  220. return s;
  221. }
  222. /*
  223. * Find a connected ROSE socket given my LCI and device.
  224. */
  225. struct sock *rose_find_socket(unsigned int lci, struct rose_neigh *neigh)
  226. {
  227. struct sock *s;
  228. struct hlist_node *node;
  229. spin_lock_bh(&rose_list_lock);
  230. sk_for_each(s, node, &rose_list) {
  231. struct rose_sock *rose = rose_sk(s);
  232. if (rose->lci == lci && rose->neighbour == neigh)
  233. goto found;
  234. }
  235. s = NULL;
  236. found:
  237. spin_unlock_bh(&rose_list_lock);
  238. return s;
  239. }
  240. /*
  241. * Find a unique LCI for a given device.
  242. */
  243. unsigned int rose_new_lci(struct rose_neigh *neigh)
  244. {
  245. int lci;
  246. if (neigh->dce_mode) {
  247. for (lci = 1; lci <= sysctl_rose_maximum_vcs; lci++)
  248. if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
  249. return lci;
  250. } else {
  251. for (lci = sysctl_rose_maximum_vcs; lci > 0; lci--)
  252. if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
  253. return lci;
  254. }
  255. return 0;
  256. }
  257. /*
  258. * Deferred destroy.
  259. */
  260. void rose_destroy_socket(struct sock *);
  261. /*
  262. * Handler for deferred kills.
  263. */
  264. static void rose_destroy_timer(unsigned long data)
  265. {
  266. rose_destroy_socket((struct sock *)data);
  267. }
  268. /*
  269. * This is called from user mode and the timers. Thus it protects itself
  270. * against interrupt users but doesn't worry about being called during
  271. * work. Once it is removed from the queue no interrupt or bottom half
  272. * will touch it and we are (fairly 8-) ) safe.
  273. */
  274. void rose_destroy_socket(struct sock *sk)
  275. {
  276. struct sk_buff *skb;
  277. rose_remove_socket(sk);
  278. rose_stop_heartbeat(sk);
  279. rose_stop_idletimer(sk);
  280. rose_stop_timer(sk);
  281. rose_clear_queues(sk); /* Flush the queues */
  282. while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
  283. if (skb->sk != sk) { /* A pending connection */
  284. /* Queue the unaccepted socket for death */
  285. sock_set_flag(skb->sk, SOCK_DEAD);
  286. rose_start_heartbeat(skb->sk);
  287. rose_sk(skb->sk)->state = ROSE_STATE_0;
  288. }
  289. kfree_skb(skb);
  290. }
  291. if (atomic_read(&sk->sk_wmem_alloc) ||
  292. atomic_read(&sk->sk_rmem_alloc)) {
  293. /* Defer: outstanding buffers */
  294. init_timer(&sk->sk_timer);
  295. sk->sk_timer.expires = jiffies + 10 * HZ;
  296. sk->sk_timer.function = rose_destroy_timer;
  297. sk->sk_timer.data = (unsigned long)sk;
  298. add_timer(&sk->sk_timer);
  299. } else
  300. sock_put(sk);
  301. }
  302. /*
  303. * Handling for system calls applied via the various interfaces to a
  304. * ROSE socket object.
  305. */
  306. static int rose_setsockopt(struct socket *sock, int level, int optname,
  307. char __user *optval, int optlen)
  308. {
  309. struct sock *sk = sock->sk;
  310. struct rose_sock *rose = rose_sk(sk);
  311. int opt;
  312. if (level != SOL_ROSE)
  313. return -ENOPROTOOPT;
  314. if (optlen < sizeof(int))
  315. return -EINVAL;
  316. if (get_user(opt, (int __user *)optval))
  317. return -EFAULT;
  318. switch (optname) {
  319. case ROSE_DEFER:
  320. rose->defer = opt ? 1 : 0;
  321. return 0;
  322. case ROSE_T1:
  323. if (opt < 1)
  324. return -EINVAL;
  325. rose->t1 = opt * HZ;
  326. return 0;
  327. case ROSE_T2:
  328. if (opt < 1)
  329. return -EINVAL;
  330. rose->t2 = opt * HZ;
  331. return 0;
  332. case ROSE_T3:
  333. if (opt < 1)
  334. return -EINVAL;
  335. rose->t3 = opt * HZ;
  336. return 0;
  337. case ROSE_HOLDBACK:
  338. if (opt < 1)
  339. return -EINVAL;
  340. rose->hb = opt * HZ;
  341. return 0;
  342. case ROSE_IDLE:
  343. if (opt < 0)
  344. return -EINVAL;
  345. rose->idle = opt * 60 * HZ;
  346. return 0;
  347. case ROSE_QBITINCL:
  348. rose->qbitincl = opt ? 1 : 0;
  349. return 0;
  350. default:
  351. return -ENOPROTOOPT;
  352. }
  353. }
  354. static int rose_getsockopt(struct socket *sock, int level, int optname,
  355. char __user *optval, int __user *optlen)
  356. {
  357. struct sock *sk = sock->sk;
  358. struct rose_sock *rose = rose_sk(sk);
  359. int val = 0;
  360. int len;
  361. if (level != SOL_ROSE)
  362. return -ENOPROTOOPT;
  363. if (get_user(len, optlen))
  364. return -EFAULT;
  365. if (len < 0)
  366. return -EINVAL;
  367. switch (optname) {
  368. case ROSE_DEFER:
  369. val = rose->defer;
  370. break;
  371. case ROSE_T1:
  372. val = rose->t1 / HZ;
  373. break;
  374. case ROSE_T2:
  375. val = rose->t2 / HZ;
  376. break;
  377. case ROSE_T3:
  378. val = rose->t3 / HZ;
  379. break;
  380. case ROSE_HOLDBACK:
  381. val = rose->hb / HZ;
  382. break;
  383. case ROSE_IDLE:
  384. val = rose->idle / (60 * HZ);
  385. break;
  386. case ROSE_QBITINCL:
  387. val = rose->qbitincl;
  388. break;
  389. default:
  390. return -ENOPROTOOPT;
  391. }
  392. len = min_t(unsigned int, len, sizeof(int));
  393. if (put_user(len, optlen))
  394. return -EFAULT;
  395. return copy_to_user(optval, &val, len) ? -EFAULT : 0;
  396. }
  397. static int rose_listen(struct socket *sock, int backlog)
  398. {
  399. struct sock *sk = sock->sk;
  400. if (sk->sk_state != TCP_LISTEN) {
  401. struct rose_sock *rose = rose_sk(sk);
  402. rose->dest_ndigis = 0;
  403. memset(&rose->dest_addr, 0, ROSE_ADDR_LEN);
  404. memset(&rose->dest_call, 0, AX25_ADDR_LEN);
  405. memset(rose->dest_digis, 0, AX25_ADDR_LEN * ROSE_MAX_DIGIS);
  406. sk->sk_max_ack_backlog = backlog;
  407. sk->sk_state = TCP_LISTEN;
  408. return 0;
  409. }
  410. return -EOPNOTSUPP;
  411. }
  412. static struct proto rose_proto = {
  413. .name = "ROSE",
  414. .owner = THIS_MODULE,
  415. .obj_size = sizeof(struct rose_sock),
  416. };
  417. static int rose_create(struct socket *sock, int protocol)
  418. {
  419. struct sock *sk;
  420. struct rose_sock *rose;
  421. if (sock->type != SOCK_SEQPACKET || protocol != 0)
  422. return -ESOCKTNOSUPPORT;
  423. if ((sk = sk_alloc(PF_ROSE, GFP_ATOMIC, &rose_proto, 1)) == NULL)
  424. return -ENOMEM;
  425. rose = rose_sk(sk);
  426. sock_init_data(sock, sk);
  427. skb_queue_head_init(&rose->ack_queue);
  428. #ifdef M_BIT
  429. skb_queue_head_init(&rose->frag_queue);
  430. rose->fraglen = 0;
  431. #endif
  432. sock->ops = &rose_proto_ops;
  433. sk->sk_protocol = protocol;
  434. init_timer(&rose->timer);
  435. init_timer(&rose->idletimer);
  436. rose->t1 = msecs_to_jiffies(sysctl_rose_call_request_timeout);
  437. rose->t2 = msecs_to_jiffies(sysctl_rose_reset_request_timeout);
  438. rose->t3 = msecs_to_jiffies(sysctl_rose_clear_request_timeout);
  439. rose->hb = msecs_to_jiffies(sysctl_rose_ack_hold_back_timeout);
  440. rose->idle = msecs_to_jiffies(sysctl_rose_no_activity_timeout);
  441. rose->state = ROSE_STATE_0;
  442. return 0;
  443. }
  444. static struct sock *rose_make_new(struct sock *osk)
  445. {
  446. struct sock *sk;
  447. struct rose_sock *rose, *orose;
  448. if (osk->sk_type != SOCK_SEQPACKET)
  449. return NULL;
  450. if ((sk = sk_alloc(PF_ROSE, GFP_ATOMIC, &rose_proto, 1)) == NULL)
  451. return NULL;
  452. rose = rose_sk(sk);
  453. sock_init_data(NULL, sk);
  454. skb_queue_head_init(&rose->ack_queue);
  455. #ifdef M_BIT
  456. skb_queue_head_init(&rose->frag_queue);
  457. rose->fraglen = 0;
  458. #endif
  459. sk->sk_type = osk->sk_type;
  460. sk->sk_socket = osk->sk_socket;
  461. sk->sk_priority = osk->sk_priority;
  462. sk->sk_protocol = osk->sk_protocol;
  463. sk->sk_rcvbuf = osk->sk_rcvbuf;
  464. sk->sk_sndbuf = osk->sk_sndbuf;
  465. sk->sk_state = TCP_ESTABLISHED;
  466. sk->sk_sleep = osk->sk_sleep;
  467. sock_copy_flags(sk, osk);
  468. init_timer(&rose->timer);
  469. init_timer(&rose->idletimer);
  470. orose = rose_sk(osk);
  471. rose->t1 = orose->t1;
  472. rose->t2 = orose->t2;
  473. rose->t3 = orose->t3;
  474. rose->hb = orose->hb;
  475. rose->idle = orose->idle;
  476. rose->defer = orose->defer;
  477. rose->device = orose->device;
  478. rose->qbitincl = orose->qbitincl;
  479. return sk;
  480. }
  481. static int rose_release(struct socket *sock)
  482. {
  483. struct sock *sk = sock->sk;
  484. struct rose_sock *rose;
  485. if (sk == NULL) return 0;
  486. rose = rose_sk(sk);
  487. switch (rose->state) {
  488. case ROSE_STATE_0:
  489. rose_disconnect(sk, 0, -1, -1);
  490. rose_destroy_socket(sk);
  491. break;
  492. case ROSE_STATE_2:
  493. rose->neighbour->use--;
  494. rose_disconnect(sk, 0, -1, -1);
  495. rose_destroy_socket(sk);
  496. break;
  497. case ROSE_STATE_1:
  498. case ROSE_STATE_3:
  499. case ROSE_STATE_4:
  500. case ROSE_STATE_5:
  501. rose_clear_queues(sk);
  502. rose_stop_idletimer(sk);
  503. rose_write_internal(sk, ROSE_CLEAR_REQUEST);
  504. rose_start_t3timer(sk);
  505. rose->state = ROSE_STATE_2;
  506. sk->sk_state = TCP_CLOSE;
  507. sk->sk_shutdown |= SEND_SHUTDOWN;
  508. sk->sk_state_change(sk);
  509. sock_set_flag(sk, SOCK_DEAD);
  510. sock_set_flag(sk, SOCK_DESTROY);
  511. break;
  512. default:
  513. break;
  514. }
  515. sock->sk = NULL;
  516. return 0;
  517. }
  518. static int rose_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
  519. {
  520. struct sock *sk = sock->sk;
  521. struct rose_sock *rose = rose_sk(sk);
  522. struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
  523. struct net_device *dev;
  524. ax25_address *source;
  525. ax25_uid_assoc *user;
  526. int n;
  527. if (!sock_flag(sk, SOCK_ZAPPED))
  528. return -EINVAL;
  529. if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
  530. return -EINVAL;
  531. if (addr->srose_family != AF_ROSE)
  532. return -EINVAL;
  533. if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
  534. return -EINVAL;
  535. if (addr->srose_ndigis > ROSE_MAX_DIGIS)
  536. return -EINVAL;
  537. if ((dev = rose_dev_get(&addr->srose_addr)) == NULL) {
  538. SOCK_DEBUG(sk, "ROSE: bind failed: invalid address\n");
  539. return -EADDRNOTAVAIL;
  540. }
  541. source = &addr->srose_call;
  542. user = ax25_findbyuid(current->euid);
  543. if (user) {
  544. rose->source_call = user->call;
  545. ax25_uid_put(user);
  546. } else {
  547. if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE))
  548. return -EACCES;
  549. rose->source_call = *source;
  550. }
  551. rose->source_addr = addr->srose_addr;
  552. rose->device = dev;
  553. rose->source_ndigis = addr->srose_ndigis;
  554. if (addr_len == sizeof(struct full_sockaddr_rose)) {
  555. struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
  556. for (n = 0 ; n < addr->srose_ndigis ; n++)
  557. rose->source_digis[n] = full_addr->srose_digis[n];
  558. } else {
  559. if (rose->source_ndigis == 1) {
  560. rose->source_digis[0] = addr->srose_digi;
  561. }
  562. }
  563. rose_insert_socket(sk);
  564. sock_reset_flag(sk, SOCK_ZAPPED);
  565. SOCK_DEBUG(sk, "ROSE: socket is bound\n");
  566. return 0;
  567. }
  568. static int rose_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags)
  569. {
  570. struct sock *sk = sock->sk;
  571. struct rose_sock *rose = rose_sk(sk);
  572. struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
  573. unsigned char cause, diagnostic;
  574. struct net_device *dev;
  575. ax25_uid_assoc *user;
  576. int n, err = 0;
  577. if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
  578. return -EINVAL;
  579. if (addr->srose_family != AF_ROSE)
  580. return -EINVAL;
  581. if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
  582. return -EINVAL;
  583. if (addr->srose_ndigis > ROSE_MAX_DIGIS)
  584. return -EINVAL;
  585. /* Source + Destination digis should not exceed ROSE_MAX_DIGIS */
  586. if ((rose->source_ndigis + addr->srose_ndigis) > ROSE_MAX_DIGIS)
  587. return -EINVAL;
  588. lock_sock(sk);
  589. if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
  590. /* Connect completed during a ERESTARTSYS event */
  591. sock->state = SS_CONNECTED;
  592. goto out_release;
  593. }
  594. if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
  595. sock->state = SS_UNCONNECTED;
  596. err = -ECONNREFUSED;
  597. goto out_release;
  598. }
  599. if (sk->sk_state == TCP_ESTABLISHED) {
  600. /* No reconnect on a seqpacket socket */
  601. err = -EISCONN;
  602. goto out_release;
  603. }
  604. sk->sk_state = TCP_CLOSE;
  605. sock->state = SS_UNCONNECTED;
  606. rose->neighbour = rose_get_neigh(&addr->srose_addr, &cause,
  607. &diagnostic);
  608. if (!rose->neighbour)
  609. return -ENETUNREACH;
  610. rose->lci = rose_new_lci(rose->neighbour);
  611. if (!rose->lci) {
  612. err = -ENETUNREACH;
  613. goto out_release;
  614. }
  615. if (sock_flag(sk, SOCK_ZAPPED)) { /* Must bind first - autobinding in this may or may not work */
  616. sock_reset_flag(sk, SOCK_ZAPPED);
  617. if ((dev = rose_dev_first()) == NULL) {
  618. err = -ENETUNREACH;
  619. goto out_release;
  620. }
  621. user = ax25_findbyuid(current->euid);
  622. if (!user) {
  623. err = -EINVAL;
  624. goto out_release;
  625. }
  626. memcpy(&rose->source_addr, dev->dev_addr, ROSE_ADDR_LEN);
  627. rose->source_call = user->call;
  628. rose->device = dev;
  629. ax25_uid_put(user);
  630. rose_insert_socket(sk); /* Finish the bind */
  631. }
  632. rose_try_next_neigh:
  633. rose->dest_addr = addr->srose_addr;
  634. rose->dest_call = addr->srose_call;
  635. rose->rand = ((long)rose & 0xFFFF) + rose->lci;
  636. rose->dest_ndigis = addr->srose_ndigis;
  637. if (addr_len == sizeof(struct full_sockaddr_rose)) {
  638. struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
  639. for (n = 0 ; n < addr->srose_ndigis ; n++)
  640. rose->dest_digis[n] = full_addr->srose_digis[n];
  641. } else {
  642. if (rose->dest_ndigis == 1) {
  643. rose->dest_digis[0] = addr->srose_digi;
  644. }
  645. }
  646. /* Move to connecting socket, start sending Connect Requests */
  647. sock->state = SS_CONNECTING;
  648. sk->sk_state = TCP_SYN_SENT;
  649. rose->state = ROSE_STATE_1;
  650. rose->neighbour->use++;
  651. rose_write_internal(sk, ROSE_CALL_REQUEST);
  652. rose_start_heartbeat(sk);
  653. rose_start_t1timer(sk);
  654. /* Now the loop */
  655. if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
  656. err = -EINPROGRESS;
  657. goto out_release;
  658. }
  659. /*
  660. * A Connect Ack with Choke or timeout or failed routing will go to
  661. * closed.
  662. */
  663. if (sk->sk_state == TCP_SYN_SENT) {
  664. struct task_struct *tsk = current;
  665. DECLARE_WAITQUEUE(wait, tsk);
  666. add_wait_queue(sk->sk_sleep, &wait);
  667. for (;;) {
  668. set_current_state(TASK_INTERRUPTIBLE);
  669. if (sk->sk_state != TCP_SYN_SENT)
  670. break;
  671. release_sock(sk);
  672. if (!signal_pending(tsk)) {
  673. schedule();
  674. lock_sock(sk);
  675. continue;
  676. }
  677. current->state = TASK_RUNNING;
  678. remove_wait_queue(sk->sk_sleep, &wait);
  679. return -ERESTARTSYS;
  680. }
  681. current->state = TASK_RUNNING;
  682. remove_wait_queue(sk->sk_sleep, &wait);
  683. }
  684. if (sk->sk_state != TCP_ESTABLISHED) {
  685. /* Try next neighbour */
  686. rose->neighbour = rose_get_neigh(&addr->srose_addr, &cause, &diagnostic);
  687. if (rose->neighbour)
  688. goto rose_try_next_neigh;
  689. /* No more neighbours */
  690. sock->state = SS_UNCONNECTED;
  691. err = sock_error(sk); /* Always set at this point */
  692. goto out_release;
  693. }
  694. sock->state = SS_CONNECTED;
  695. out_release:
  696. release_sock(sk);
  697. return err;
  698. }
  699. static int rose_accept(struct socket *sock, struct socket *newsock, int flags)
  700. {
  701. struct task_struct *tsk = current;
  702. DECLARE_WAITQUEUE(wait, tsk);
  703. struct sk_buff *skb;
  704. struct sock *newsk;
  705. struct sock *sk;
  706. int err = 0;
  707. if ((sk = sock->sk) == NULL)
  708. return -EINVAL;
  709. lock_sock(sk);
  710. if (sk->sk_type != SOCK_SEQPACKET) {
  711. err = -EOPNOTSUPP;
  712. goto out;
  713. }
  714. if (sk->sk_state != TCP_LISTEN) {
  715. err = -EINVAL;
  716. goto out;
  717. }
  718. /*
  719. * The write queue this time is holding sockets ready to use
  720. * hooked into the SABM we saved
  721. */
  722. add_wait_queue(sk->sk_sleep, &wait);
  723. for (;;) {
  724. skb = skb_dequeue(&sk->sk_receive_queue);
  725. if (skb)
  726. break;
  727. current->state = TASK_INTERRUPTIBLE;
  728. release_sock(sk);
  729. if (flags & O_NONBLOCK) {
  730. current->state = TASK_RUNNING;
  731. remove_wait_queue(sk->sk_sleep, &wait);
  732. return -EWOULDBLOCK;
  733. }
  734. if (!signal_pending(tsk)) {
  735. schedule();
  736. lock_sock(sk);
  737. continue;
  738. }
  739. current->state = TASK_RUNNING;
  740. remove_wait_queue(sk->sk_sleep, &wait);
  741. return -ERESTARTSYS;
  742. }
  743. current->state = TASK_RUNNING;
  744. remove_wait_queue(sk->sk_sleep, &wait);
  745. newsk = skb->sk;
  746. newsk->sk_socket = newsock;
  747. newsk->sk_sleep = &newsock->wait;
  748. /* Now attach up the new socket */
  749. skb->sk = NULL;
  750. kfree_skb(skb);
  751. sk->sk_ack_backlog--;
  752. newsock->sk = newsk;
  753. out:
  754. release_sock(sk);
  755. return err;
  756. }
  757. static int rose_getname(struct socket *sock, struct sockaddr *uaddr,
  758. int *uaddr_len, int peer)
  759. {
  760. struct full_sockaddr_rose *srose = (struct full_sockaddr_rose *)uaddr;
  761. struct sock *sk = sock->sk;
  762. struct rose_sock *rose = rose_sk(sk);
  763. int n;
  764. if (peer != 0) {
  765. if (sk->sk_state != TCP_ESTABLISHED)
  766. return -ENOTCONN;
  767. srose->srose_family = AF_ROSE;
  768. srose->srose_addr = rose->dest_addr;
  769. srose->srose_call = rose->dest_call;
  770. srose->srose_ndigis = rose->dest_ndigis;
  771. for (n = 0; n < rose->dest_ndigis; n++)
  772. srose->srose_digis[n] = rose->dest_digis[n];
  773. } else {
  774. srose->srose_family = AF_ROSE;
  775. srose->srose_addr = rose->source_addr;
  776. srose->srose_call = rose->source_call;
  777. srose->srose_ndigis = rose->source_ndigis;
  778. for (n = 0; n < rose->source_ndigis; n++)
  779. srose->srose_digis[n] = rose->source_digis[n];
  780. }
  781. *uaddr_len = sizeof(struct full_sockaddr_rose);
  782. return 0;
  783. }
  784. int rose_rx_call_request(struct sk_buff *skb, struct net_device *dev, struct rose_neigh *neigh, unsigned int lci)
  785. {
  786. struct sock *sk;
  787. struct sock *make;
  788. struct rose_sock *make_rose;
  789. struct rose_facilities_struct facilities;
  790. int n, len;
  791. skb->sk = NULL; /* Initially we don't know who it's for */
  792. /*
  793. * skb->data points to the rose frame start
  794. */
  795. memset(&facilities, 0x00, sizeof(struct rose_facilities_struct));
  796. len = (((skb->data[3] >> 4) & 0x0F) + 1) / 2;
  797. len += (((skb->data[3] >> 0) & 0x0F) + 1) / 2;
  798. if (!rose_parse_facilities(skb->data + len + 4, &facilities)) {
  799. rose_transmit_clear_request(neigh, lci, ROSE_INVALID_FACILITY, 76);
  800. return 0;
  801. }
  802. sk = rose_find_listener(&facilities.source_addr, &facilities.source_call);
  803. /*
  804. * We can't accept the Call Request.
  805. */
  806. if (sk == NULL || sk_acceptq_is_full(sk) ||
  807. (make = rose_make_new(sk)) == NULL) {
  808. rose_transmit_clear_request(neigh, lci, ROSE_NETWORK_CONGESTION, 120);
  809. return 0;
  810. }
  811. skb->sk = make;
  812. make->sk_state = TCP_ESTABLISHED;
  813. make_rose = rose_sk(make);
  814. make_rose->lci = lci;
  815. make_rose->dest_addr = facilities.dest_addr;
  816. make_rose->dest_call = facilities.dest_call;
  817. make_rose->dest_ndigis = facilities.dest_ndigis;
  818. for (n = 0 ; n < facilities.dest_ndigis ; n++)
  819. make_rose->dest_digis[n] = facilities.dest_digis[n];
  820. make_rose->source_addr = facilities.source_addr;
  821. make_rose->source_call = facilities.source_call;
  822. make_rose->source_ndigis = facilities.source_ndigis;
  823. for (n = 0 ; n < facilities.source_ndigis ; n++)
  824. make_rose->source_digis[n]= facilities.source_digis[n];
  825. make_rose->neighbour = neigh;
  826. make_rose->device = dev;
  827. make_rose->facilities = facilities;
  828. make_rose->neighbour->use++;
  829. if (rose_sk(sk)->defer) {
  830. make_rose->state = ROSE_STATE_5;
  831. } else {
  832. rose_write_internal(make, ROSE_CALL_ACCEPTED);
  833. make_rose->state = ROSE_STATE_3;
  834. rose_start_idletimer(make);
  835. }
  836. make_rose->condition = 0x00;
  837. make_rose->vs = 0;
  838. make_rose->va = 0;
  839. make_rose->vr = 0;
  840. make_rose->vl = 0;
  841. sk->sk_ack_backlog++;
  842. rose_insert_socket(make);
  843. skb_queue_head(&sk->sk_receive_queue, skb);
  844. rose_start_heartbeat(make);
  845. if (!sock_flag(sk, SOCK_DEAD))
  846. sk->sk_data_ready(sk, skb->len);
  847. return 1;
  848. }
  849. static int rose_sendmsg(struct kiocb *iocb, struct socket *sock,
  850. struct msghdr *msg, size_t len)
  851. {
  852. struct sock *sk = sock->sk;
  853. struct rose_sock *rose = rose_sk(sk);
  854. struct sockaddr_rose *usrose = (struct sockaddr_rose *)msg->msg_name;
  855. int err;
  856. struct full_sockaddr_rose srose;
  857. struct sk_buff *skb;
  858. unsigned char *asmptr;
  859. int n, size, qbit = 0;
  860. if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
  861. return -EINVAL;
  862. if (sock_flag(sk, SOCK_ZAPPED))
  863. return -EADDRNOTAVAIL;
  864. if (sk->sk_shutdown & SEND_SHUTDOWN) {
  865. send_sig(SIGPIPE, current, 0);
  866. return -EPIPE;
  867. }
  868. if (rose->neighbour == NULL || rose->device == NULL)
  869. return -ENETUNREACH;
  870. if (usrose != NULL) {
  871. if (msg->msg_namelen != sizeof(struct sockaddr_rose) && msg->msg_namelen != sizeof(struct full_sockaddr_rose))
  872. return -EINVAL;
  873. memset(&srose, 0, sizeof(struct full_sockaddr_rose));
  874. memcpy(&srose, usrose, msg->msg_namelen);
  875. if (rosecmp(&rose->dest_addr, &srose.srose_addr) != 0 ||
  876. ax25cmp(&rose->dest_call, &srose.srose_call) != 0)
  877. return -EISCONN;
  878. if (srose.srose_ndigis != rose->dest_ndigis)
  879. return -EISCONN;
  880. if (srose.srose_ndigis == rose->dest_ndigis) {
  881. for (n = 0 ; n < srose.srose_ndigis ; n++)
  882. if (ax25cmp(&rose->dest_digis[n],
  883. &srose.srose_digis[n]))
  884. return -EISCONN;
  885. }
  886. if (srose.srose_family != AF_ROSE)
  887. return -EINVAL;
  888. } else {
  889. if (sk->sk_state != TCP_ESTABLISHED)
  890. return -ENOTCONN;
  891. srose.srose_family = AF_ROSE;
  892. srose.srose_addr = rose->dest_addr;
  893. srose.srose_call = rose->dest_call;
  894. srose.srose_ndigis = rose->dest_ndigis;
  895. for (n = 0 ; n < rose->dest_ndigis ; n++)
  896. srose.srose_digis[n] = rose->dest_digis[n];
  897. }
  898. SOCK_DEBUG(sk, "ROSE: sendto: Addresses built.\n");
  899. /* Build a packet */
  900. SOCK_DEBUG(sk, "ROSE: sendto: building packet.\n");
  901. size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN;
  902. if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
  903. return err;
  904. skb_reserve(skb, AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN);
  905. /*
  906. * Put the data on the end
  907. */
  908. SOCK_DEBUG(sk, "ROSE: Appending user data\n");
  909. asmptr = skb->h.raw = skb_put(skb, len);
  910. err = memcpy_fromiovec(asmptr, msg->msg_iov, len);
  911. if (err) {
  912. kfree_skb(skb);
  913. return err;
  914. }
  915. /*
  916. * If the Q BIT Include socket option is in force, the first
  917. * byte of the user data is the logical value of the Q Bit.
  918. */
  919. if (rose->qbitincl) {
  920. qbit = skb->data[0];
  921. skb_pull(skb, 1);
  922. }
  923. /*
  924. * Push down the ROSE header
  925. */
  926. asmptr = skb_push(skb, ROSE_MIN_LEN);
  927. SOCK_DEBUG(sk, "ROSE: Building Network Header.\n");
  928. /* Build a ROSE Network header */
  929. asmptr[0] = ((rose->lci >> 8) & 0x0F) | ROSE_GFI;
  930. asmptr[1] = (rose->lci >> 0) & 0xFF;
  931. asmptr[2] = ROSE_DATA;
  932. if (qbit)
  933. asmptr[0] |= ROSE_Q_BIT;
  934. SOCK_DEBUG(sk, "ROSE: Built header.\n");
  935. SOCK_DEBUG(sk, "ROSE: Transmitting buffer\n");
  936. if (sk->sk_state != TCP_ESTABLISHED) {
  937. kfree_skb(skb);
  938. return -ENOTCONN;
  939. }
  940. #ifdef M_BIT
  941. #define ROSE_PACLEN (256-ROSE_MIN_LEN)
  942. if (skb->len - ROSE_MIN_LEN > ROSE_PACLEN) {
  943. unsigned char header[ROSE_MIN_LEN];
  944. struct sk_buff *skbn;
  945. int frontlen;
  946. int lg;
  947. /* Save a copy of the Header */
  948. memcpy(header, skb->data, ROSE_MIN_LEN);
  949. skb_pull(skb, ROSE_MIN_LEN);
  950. frontlen = skb_headroom(skb);
  951. while (skb->len > 0) {
  952. if ((skbn = sock_alloc_send_skb(sk, frontlen + ROSE_PACLEN, 0, &err)) == NULL) {
  953. kfree_skb(skb);
  954. return err;
  955. }
  956. skbn->sk = sk;
  957. skbn->free = 1;
  958. skbn->arp = 1;
  959. skb_reserve(skbn, frontlen);
  960. lg = (ROSE_PACLEN > skb->len) ? skb->len : ROSE_PACLEN;
  961. /* Copy the user data */
  962. memcpy(skb_put(skbn, lg), skb->data, lg);
  963. skb_pull(skb, lg);
  964. /* Duplicate the Header */
  965. skb_push(skbn, ROSE_MIN_LEN);
  966. memcpy(skbn->data, header, ROSE_MIN_LEN);
  967. if (skb->len > 0)
  968. skbn->data[2] |= M_BIT;
  969. skb_queue_tail(&sk->sk_write_queue, skbn); /* Throw it on the queue */
  970. }
  971. skb->free = 1;
  972. kfree_skb(skb);
  973. } else {
  974. skb_queue_tail(&sk->sk_write_queue, skb); /* Throw it on the queue */
  975. }
  976. #else
  977. skb_queue_tail(&sk->sk_write_queue, skb); /* Shove it onto the queue */
  978. #endif
  979. rose_kick(sk);
  980. return len;
  981. }
  982. static int rose_recvmsg(struct kiocb *iocb, struct socket *sock,
  983. struct msghdr *msg, size_t size, int flags)
  984. {
  985. struct sock *sk = sock->sk;
  986. struct rose_sock *rose = rose_sk(sk);
  987. struct sockaddr_rose *srose = (struct sockaddr_rose *)msg->msg_name;
  988. size_t copied;
  989. unsigned char *asmptr;
  990. struct sk_buff *skb;
  991. int n, er, qbit;
  992. /*
  993. * This works for seqpacket too. The receiver has ordered the queue for
  994. * us! We do one quick check first though
  995. */
  996. if (sk->sk_state != TCP_ESTABLISHED)
  997. return -ENOTCONN;
  998. /* Now we can treat all alike */
  999. if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL)
  1000. return er;
  1001. qbit = (skb->data[0] & ROSE_Q_BIT) == ROSE_Q_BIT;
  1002. skb_pull(skb, ROSE_MIN_LEN);
  1003. if (rose->qbitincl) {
  1004. asmptr = skb_push(skb, 1);
  1005. *asmptr = qbit;
  1006. }
  1007. skb->h.raw = skb->data;
  1008. copied = skb->len;
  1009. if (copied > size) {
  1010. copied = size;
  1011. msg->msg_flags |= MSG_TRUNC;
  1012. }
  1013. skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  1014. if (srose != NULL) {
  1015. srose->srose_family = AF_ROSE;
  1016. srose->srose_addr = rose->dest_addr;
  1017. srose->srose_call = rose->dest_call;
  1018. srose->srose_ndigis = rose->dest_ndigis;
  1019. if (msg->msg_namelen >= sizeof(struct full_sockaddr_rose)) {
  1020. struct full_sockaddr_rose *full_srose = (struct full_sockaddr_rose *)msg->msg_name;
  1021. for (n = 0 ; n < rose->dest_ndigis ; n++)
  1022. full_srose->srose_digis[n] = rose->dest_digis[n];
  1023. msg->msg_namelen = sizeof(struct full_sockaddr_rose);
  1024. } else {
  1025. if (rose->dest_ndigis >= 1) {
  1026. srose->srose_ndigis = 1;
  1027. srose->srose_digi = rose->dest_digis[0];
  1028. }
  1029. msg->msg_namelen = sizeof(struct sockaddr_rose);
  1030. }
  1031. }
  1032. skb_free_datagram(sk, skb);
  1033. return copied;
  1034. }
  1035. static int rose_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
  1036. {
  1037. struct sock *sk = sock->sk;
  1038. struct rose_sock *rose = rose_sk(sk);
  1039. void __user *argp = (void __user *)arg;
  1040. switch (cmd) {
  1041. case TIOCOUTQ: {
  1042. long amount;
  1043. amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
  1044. if (amount < 0)
  1045. amount = 0;
  1046. return put_user(amount, (unsigned int __user *) argp);
  1047. }
  1048. case TIOCINQ: {
  1049. struct sk_buff *skb;
  1050. long amount = 0L;
  1051. /* These two are safe on a single CPU system as only user tasks fiddle here */
  1052. if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
  1053. amount = skb->len;
  1054. return put_user(amount, (unsigned int __user *) argp);
  1055. }
  1056. case SIOCGSTAMP:
  1057. return sock_get_timestamp(sk, (struct timeval __user *) argp);
  1058. case SIOCGIFADDR:
  1059. case SIOCSIFADDR:
  1060. case SIOCGIFDSTADDR:
  1061. case SIOCSIFDSTADDR:
  1062. case SIOCGIFBRDADDR:
  1063. case SIOCSIFBRDADDR:
  1064. case SIOCGIFNETMASK:
  1065. case SIOCSIFNETMASK:
  1066. case SIOCGIFMETRIC:
  1067. case SIOCSIFMETRIC:
  1068. return -EINVAL;
  1069. case SIOCADDRT:
  1070. case SIOCDELRT:
  1071. case SIOCRSCLRRT:
  1072. if (!capable(CAP_NET_ADMIN))
  1073. return -EPERM;
  1074. return rose_rt_ioctl(cmd, argp);
  1075. case SIOCRSGCAUSE: {
  1076. struct rose_cause_struct rose_cause;
  1077. rose_cause.cause = rose->cause;
  1078. rose_cause.diagnostic = rose->diagnostic;
  1079. return copy_to_user(argp, &rose_cause, sizeof(struct rose_cause_struct)) ? -EFAULT : 0;
  1080. }
  1081. case SIOCRSSCAUSE: {
  1082. struct rose_cause_struct rose_cause;
  1083. if (copy_from_user(&rose_cause, argp, sizeof(struct rose_cause_struct)))
  1084. return -EFAULT;
  1085. rose->cause = rose_cause.cause;
  1086. rose->diagnostic = rose_cause.diagnostic;
  1087. return 0;
  1088. }
  1089. case SIOCRSSL2CALL:
  1090. if (!capable(CAP_NET_ADMIN)) return -EPERM;
  1091. if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
  1092. ax25_listen_release(&rose_callsign, NULL);
  1093. if (copy_from_user(&rose_callsign, argp, sizeof(ax25_address)))
  1094. return -EFAULT;
  1095. if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
  1096. return ax25_listen_register(&rose_callsign, NULL);
  1097. return 0;
  1098. case SIOCRSGL2CALL:
  1099. return copy_to_user(argp, &rose_callsign, sizeof(ax25_address)) ? -EFAULT : 0;
  1100. case SIOCRSACCEPT:
  1101. if (rose->state == ROSE_STATE_5) {
  1102. rose_write_internal(sk, ROSE_CALL_ACCEPTED);
  1103. rose_start_idletimer(sk);
  1104. rose->condition = 0x00;
  1105. rose->vs = 0;
  1106. rose->va = 0;
  1107. rose->vr = 0;
  1108. rose->vl = 0;
  1109. rose->state = ROSE_STATE_3;
  1110. }
  1111. return 0;
  1112. default:
  1113. return -ENOIOCTLCMD;
  1114. }
  1115. return 0;
  1116. }
  1117. #ifdef CONFIG_PROC_FS
  1118. static void *rose_info_start(struct seq_file *seq, loff_t *pos)
  1119. {
  1120. int i;
  1121. struct sock *s;
  1122. struct hlist_node *node;
  1123. spin_lock_bh(&rose_list_lock);
  1124. if (*pos == 0)
  1125. return SEQ_START_TOKEN;
  1126. i = 1;
  1127. sk_for_each(s, node, &rose_list) {
  1128. if (i == *pos)
  1129. return s;
  1130. ++i;
  1131. }
  1132. return NULL;
  1133. }
  1134. static void *rose_info_next(struct seq_file *seq, void *v, loff_t *pos)
  1135. {
  1136. ++*pos;
  1137. return (v == SEQ_START_TOKEN) ? sk_head(&rose_list)
  1138. : sk_next((struct sock *)v);
  1139. }
  1140. static void rose_info_stop(struct seq_file *seq, void *v)
  1141. {
  1142. spin_unlock_bh(&rose_list_lock);
  1143. }
  1144. static int rose_info_show(struct seq_file *seq, void *v)
  1145. {
  1146. char buf[11];
  1147. if (v == SEQ_START_TOKEN)
  1148. seq_puts(seq,
  1149. "dest_addr dest_call src_addr src_call dev lci neigh st vs vr va t t1 t2 t3 hb idle Snd-Q Rcv-Q inode\n");
  1150. else {
  1151. struct sock *s = v;
  1152. struct rose_sock *rose = rose_sk(s);
  1153. const char *devname, *callsign;
  1154. const struct net_device *dev = rose->device;
  1155. if (!dev)
  1156. devname = "???";
  1157. else
  1158. devname = dev->name;
  1159. seq_printf(seq, "%-10s %-9s ",
  1160. rose2asc(&rose->dest_addr),
  1161. ax2asc(buf, &rose->dest_call));
  1162. if (ax25cmp(&rose->source_call, &null_ax25_address) == 0)
  1163. callsign = "??????-?";
  1164. else
  1165. callsign = ax2asc(buf, &rose->source_call);
  1166. seq_printf(seq,
  1167. "%-10s %-9s %-5s %3.3X %05d %d %d %d %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %ld\n",
  1168. rose2asc(&rose->source_addr),
  1169. callsign,
  1170. devname,
  1171. rose->lci & 0x0FFF,
  1172. (rose->neighbour) ? rose->neighbour->number : 0,
  1173. rose->state,
  1174. rose->vs,
  1175. rose->vr,
  1176. rose->va,
  1177. ax25_display_timer(&rose->timer) / HZ,
  1178. rose->t1 / HZ,
  1179. rose->t2 / HZ,
  1180. rose->t3 / HZ,
  1181. rose->hb / HZ,
  1182. ax25_display_timer(&rose->idletimer) / (60 * HZ),
  1183. rose->idle / (60 * HZ),
  1184. atomic_read(&s->sk_wmem_alloc),
  1185. atomic_read(&s->sk_rmem_alloc),
  1186. s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
  1187. }
  1188. return 0;
  1189. }
  1190. static struct seq_operations rose_info_seqops = {
  1191. .start = rose_info_start,
  1192. .next = rose_info_next,
  1193. .stop = rose_info_stop,
  1194. .show = rose_info_show,
  1195. };
  1196. static int rose_info_open(struct inode *inode, struct file *file)
  1197. {
  1198. return seq_open(file, &rose_info_seqops);
  1199. }
  1200. static const struct file_operations rose_info_fops = {
  1201. .owner = THIS_MODULE,
  1202. .open = rose_info_open,
  1203. .read = seq_read,
  1204. .llseek = seq_lseek,
  1205. .release = seq_release,
  1206. };
  1207. #endif /* CONFIG_PROC_FS */
  1208. static struct net_proto_family rose_family_ops = {
  1209. .family = PF_ROSE,
  1210. .create = rose_create,
  1211. .owner = THIS_MODULE,
  1212. };
  1213. static struct proto_ops rose_proto_ops = {
  1214. .family = PF_ROSE,
  1215. .owner = THIS_MODULE,
  1216. .release = rose_release,
  1217. .bind = rose_bind,
  1218. .connect = rose_connect,
  1219. .socketpair = sock_no_socketpair,
  1220. .accept = rose_accept,
  1221. .getname = rose_getname,
  1222. .poll = datagram_poll,
  1223. .ioctl = rose_ioctl,
  1224. .listen = rose_listen,
  1225. .shutdown = sock_no_shutdown,
  1226. .setsockopt = rose_setsockopt,
  1227. .getsockopt = rose_getsockopt,
  1228. .sendmsg = rose_sendmsg,
  1229. .recvmsg = rose_recvmsg,
  1230. .mmap = sock_no_mmap,
  1231. .sendpage = sock_no_sendpage,
  1232. };
  1233. static struct notifier_block rose_dev_notifier = {
  1234. .notifier_call = rose_device_event,
  1235. };
  1236. static struct net_device **dev_rose;
  1237. static struct ax25_protocol rose_pid = {
  1238. .pid = AX25_P_ROSE,
  1239. .func = rose_route_frame
  1240. };
  1241. static struct ax25_linkfail rose_linkfail_notifier = {
  1242. .func = rose_link_failed
  1243. };
  1244. static int __init rose_proto_init(void)
  1245. {
  1246. int i;
  1247. int rc;
  1248. if (rose_ndevs > 0x7FFFFFFF/sizeof(struct net_device *)) {
  1249. printk(KERN_ERR "ROSE: rose_proto_init - rose_ndevs parameter to large\n");
  1250. rc = -EINVAL;
  1251. goto out;
  1252. }
  1253. rc = proto_register(&rose_proto, 0);
  1254. if (rc != 0)
  1255. goto out;
  1256. rose_callsign = null_ax25_address;
  1257. dev_rose = kzalloc(rose_ndevs * sizeof(struct net_device *), GFP_KERNEL);
  1258. if (dev_rose == NULL) {
  1259. printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate device structure\n");
  1260. rc = -ENOMEM;
  1261. goto out_proto_unregister;
  1262. }
  1263. for (i = 0; i < rose_ndevs; i++) {
  1264. struct net_device *dev;
  1265. char name[IFNAMSIZ];
  1266. sprintf(name, "rose%d", i);
  1267. dev = alloc_netdev(sizeof(struct net_device_stats),
  1268. name, rose_setup);
  1269. if (!dev) {
  1270. printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate memory\n");
  1271. rc = -ENOMEM;
  1272. goto fail;
  1273. }
  1274. rc = register_netdev(dev);
  1275. if (rc) {
  1276. printk(KERN_ERR "ROSE: netdevice registration failed\n");
  1277. free_netdev(dev);
  1278. goto fail;
  1279. }
  1280. lockdep_set_class(&dev->_xmit_lock, &rose_netdev_xmit_lock_key);
  1281. dev_rose[i] = dev;
  1282. }
  1283. sock_register(&rose_family_ops);
  1284. register_netdevice_notifier(&rose_dev_notifier);
  1285. ax25_register_pid(&rose_pid);
  1286. ax25_linkfail_register(&rose_linkfail_notifier);
  1287. #ifdef CONFIG_SYSCTL
  1288. rose_register_sysctl();
  1289. #endif
  1290. rose_loopback_init();
  1291. rose_add_loopback_neigh();
  1292. proc_net_fops_create("rose", S_IRUGO, &rose_info_fops);
  1293. proc_net_fops_create("rose_neigh", S_IRUGO, &rose_neigh_fops);
  1294. proc_net_fops_create("rose_nodes", S_IRUGO, &rose_nodes_fops);
  1295. proc_net_fops_create("rose_routes", S_IRUGO, &rose_routes_fops);
  1296. out:
  1297. return rc;
  1298. fail:
  1299. while (--i >= 0) {
  1300. unregister_netdev(dev_rose[i]);
  1301. free_netdev(dev_rose[i]);
  1302. }
  1303. kfree(dev_rose);
  1304. out_proto_unregister:
  1305. proto_unregister(&rose_proto);
  1306. goto out;
  1307. }
  1308. module_init(rose_proto_init);
  1309. module_param(rose_ndevs, int, 0);
  1310. MODULE_PARM_DESC(rose_ndevs, "number of ROSE devices");
  1311. MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
  1312. MODULE_DESCRIPTION("The amateur radio ROSE network layer protocol");
  1313. MODULE_LICENSE("GPL");
  1314. MODULE_ALIAS_NETPROTO(PF_ROSE);
  1315. static void __exit rose_exit(void)
  1316. {
  1317. int i;
  1318. proc_net_remove("rose");
  1319. proc_net_remove("rose_neigh");
  1320. proc_net_remove("rose_nodes");
  1321. proc_net_remove("rose_routes");
  1322. rose_loopback_clear();
  1323. rose_rt_free();
  1324. ax25_protocol_release(AX25_P_ROSE);
  1325. ax25_linkfail_release(&rose_linkfail_notifier);
  1326. if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
  1327. ax25_listen_release(&rose_callsign, NULL);
  1328. #ifdef CONFIG_SYSCTL
  1329. rose_unregister_sysctl();
  1330. #endif
  1331. unregister_netdevice_notifier(&rose_dev_notifier);
  1332. sock_unregister(PF_ROSE);
  1333. for (i = 0; i < rose_ndevs; i++) {
  1334. struct net_device *dev = dev_rose[i];
  1335. if (dev) {
  1336. unregister_netdev(dev);
  1337. free_netdev(dev);
  1338. }
  1339. }
  1340. kfree(dev_rose);
  1341. proto_unregister(&rose_proto);
  1342. }
  1343. module_exit(rose_exit);