x25_in.c 8.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362
  1. /*
  2. * X.25 Packet Layer release 002
  3. *
  4. * This is ALPHA test software. This code may break your machine,
  5. * randomly fail to work with new releases, misbehave and/or generally
  6. * screw up. It might even work.
  7. *
  8. * This code REQUIRES 2.1.15 or higher
  9. *
  10. * This module:
  11. * This module is free software; you can redistribute it and/or
  12. * modify it under the terms of the GNU General Public License
  13. * as published by the Free Software Foundation; either version
  14. * 2 of the License, or (at your option) any later version.
  15. *
  16. * History
  17. * X.25 001 Jonathan Naylor Started coding.
  18. * X.25 002 Jonathan Naylor Centralised disconnection code.
  19. * New timer architecture.
  20. * 2000-03-20 Daniela Squassoni Disabling/enabling of facilities
  21. * negotiation.
  22. * 2000-11-10 Henner Eisen Check and reset for out-of-sequence
  23. * i-frames.
  24. */
  25. #include <linux/errno.h>
  26. #include <linux/kernel.h>
  27. #include <linux/string.h>
  28. #include <linux/skbuff.h>
  29. #include <net/sock.h>
  30. #include <net/tcp_states.h>
  31. #include <net/x25.h>
  32. static int x25_queue_rx_frame(struct sock *sk, struct sk_buff *skb, int more)
  33. {
  34. struct sk_buff *skbo, *skbn = skb;
  35. struct x25_sock *x25 = x25_sk(sk);
  36. if (more) {
  37. x25->fraglen += skb->len;
  38. skb_queue_tail(&x25->fragment_queue, skb);
  39. skb_set_owner_r(skb, sk);
  40. return 0;
  41. }
  42. if (!more && x25->fraglen > 0) { /* End of fragment */
  43. int len = x25->fraglen + skb->len;
  44. if ((skbn = alloc_skb(len, GFP_ATOMIC)) == NULL){
  45. kfree_skb(skb);
  46. return 1;
  47. }
  48. skb_queue_tail(&x25->fragment_queue, skb);
  49. skbn->h.raw = skbn->data;
  50. skbo = skb_dequeue(&x25->fragment_queue);
  51. memcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
  52. kfree_skb(skbo);
  53. while ((skbo =
  54. skb_dequeue(&x25->fragment_queue)) != NULL) {
  55. skb_pull(skbo, (x25->neighbour->extended) ?
  56. X25_EXT_MIN_LEN : X25_STD_MIN_LEN);
  57. memcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
  58. kfree_skb(skbo);
  59. }
  60. x25->fraglen = 0;
  61. }
  62. skb_set_owner_r(skbn, sk);
  63. skb_queue_tail(&sk->sk_receive_queue, skbn);
  64. if (!sock_flag(sk, SOCK_DEAD))
  65. sk->sk_data_ready(sk, skbn->len);
  66. return 0;
  67. }
  68. /*
  69. * State machine for state 1, Awaiting Call Accepted State.
  70. * The handling of the timer(s) is in file x25_timer.c.
  71. * Handling of state 0 and connection release is in af_x25.c.
  72. */
  73. static int x25_state1_machine(struct sock *sk, struct sk_buff *skb, int frametype)
  74. {
  75. struct x25_address source_addr, dest_addr;
  76. switch (frametype) {
  77. case X25_CALL_ACCEPTED: {
  78. struct x25_sock *x25 = x25_sk(sk);
  79. x25_stop_timer(sk);
  80. x25->condition = 0x00;
  81. x25->vs = 0;
  82. x25->va = 0;
  83. x25->vr = 0;
  84. x25->vl = 0;
  85. x25->state = X25_STATE_3;
  86. sk->sk_state = TCP_ESTABLISHED;
  87. /*
  88. * Parse the data in the frame.
  89. */
  90. skb_pull(skb, X25_STD_MIN_LEN);
  91. skb_pull(skb, x25_addr_ntoa(skb->data, &source_addr, &dest_addr));
  92. skb_pull(skb,
  93. x25_parse_facilities(skb, &x25->facilities,
  94. &x25->dte_facilities,
  95. &x25->vc_facil_mask));
  96. /*
  97. * Copy any Call User Data.
  98. */
  99. if (skb->len >= 0) {
  100. memcpy(x25->calluserdata.cuddata, skb->data,
  101. skb->len);
  102. x25->calluserdata.cudlength = skb->len;
  103. }
  104. if (!sock_flag(sk, SOCK_DEAD))
  105. sk->sk_state_change(sk);
  106. break;
  107. }
  108. case X25_CLEAR_REQUEST:
  109. x25_write_internal(sk, X25_CLEAR_CONFIRMATION);
  110. x25_disconnect(sk, ECONNREFUSED, skb->data[3], skb->data[4]);
  111. break;
  112. default:
  113. break;
  114. }
  115. return 0;
  116. }
  117. /*
  118. * State machine for state 2, Awaiting Clear Confirmation State.
  119. * The handling of the timer(s) is in file x25_timer.c
  120. * Handling of state 0 and connection release is in af_x25.c.
  121. */
  122. static int x25_state2_machine(struct sock *sk, struct sk_buff *skb, int frametype)
  123. {
  124. switch (frametype) {
  125. case X25_CLEAR_REQUEST:
  126. x25_write_internal(sk, X25_CLEAR_CONFIRMATION);
  127. x25_disconnect(sk, 0, skb->data[3], skb->data[4]);
  128. break;
  129. case X25_CLEAR_CONFIRMATION:
  130. x25_disconnect(sk, 0, 0, 0);
  131. break;
  132. default:
  133. break;
  134. }
  135. return 0;
  136. }
  137. /*
  138. * State machine for state 3, Connected State.
  139. * The handling of the timer(s) is in file x25_timer.c
  140. * Handling of state 0 and connection release is in af_x25.c.
  141. */
  142. static int x25_state3_machine(struct sock *sk, struct sk_buff *skb, int frametype, int ns, int nr, int q, int d, int m)
  143. {
  144. int queued = 0;
  145. int modulus;
  146. struct x25_sock *x25 = x25_sk(sk);
  147. modulus = (x25->neighbour->extended) ? X25_EMODULUS : X25_SMODULUS;
  148. switch (frametype) {
  149. case X25_RESET_REQUEST:
  150. x25_write_internal(sk, X25_RESET_CONFIRMATION);
  151. x25_stop_timer(sk);
  152. x25->condition = 0x00;
  153. x25->vs = 0;
  154. x25->vr = 0;
  155. x25->va = 0;
  156. x25->vl = 0;
  157. x25_requeue_frames(sk);
  158. break;
  159. case X25_CLEAR_REQUEST:
  160. x25_write_internal(sk, X25_CLEAR_CONFIRMATION);
  161. x25_disconnect(sk, 0, skb->data[3], skb->data[4]);
  162. break;
  163. case X25_RR:
  164. case X25_RNR:
  165. if (!x25_validate_nr(sk, nr)) {
  166. x25_clear_queues(sk);
  167. x25_write_internal(sk, X25_RESET_REQUEST);
  168. x25_start_t22timer(sk);
  169. x25->condition = 0x00;
  170. x25->vs = 0;
  171. x25->vr = 0;
  172. x25->va = 0;
  173. x25->vl = 0;
  174. x25->state = X25_STATE_4;
  175. } else {
  176. x25_frames_acked(sk, nr);
  177. if (frametype == X25_RNR) {
  178. x25->condition |= X25_COND_PEER_RX_BUSY;
  179. } else {
  180. x25->condition &= ~X25_COND_PEER_RX_BUSY;
  181. }
  182. }
  183. break;
  184. case X25_DATA: /* XXX */
  185. x25->condition &= ~X25_COND_PEER_RX_BUSY;
  186. if ((ns != x25->vr) || !x25_validate_nr(sk, nr)) {
  187. x25_clear_queues(sk);
  188. x25_write_internal(sk, X25_RESET_REQUEST);
  189. x25_start_t22timer(sk);
  190. x25->condition = 0x00;
  191. x25->vs = 0;
  192. x25->vr = 0;
  193. x25->va = 0;
  194. x25->vl = 0;
  195. x25->state = X25_STATE_4;
  196. break;
  197. }
  198. x25_frames_acked(sk, nr);
  199. if (ns == x25->vr) {
  200. if (x25_queue_rx_frame(sk, skb, m) == 0) {
  201. x25->vr = (x25->vr + 1) % modulus;
  202. queued = 1;
  203. } else {
  204. /* Should never happen */
  205. x25_clear_queues(sk);
  206. x25_write_internal(sk, X25_RESET_REQUEST);
  207. x25_start_t22timer(sk);
  208. x25->condition = 0x00;
  209. x25->vs = 0;
  210. x25->vr = 0;
  211. x25->va = 0;
  212. x25->vl = 0;
  213. x25->state = X25_STATE_4;
  214. break;
  215. }
  216. if (atomic_read(&sk->sk_rmem_alloc) >
  217. (sk->sk_rcvbuf / 2))
  218. x25->condition |= X25_COND_OWN_RX_BUSY;
  219. }
  220. /*
  221. * If the window is full Ack it immediately, else
  222. * start the holdback timer.
  223. */
  224. if (((x25->vl + x25->facilities.winsize_in) % modulus) == x25->vr) {
  225. x25->condition &= ~X25_COND_ACK_PENDING;
  226. x25_stop_timer(sk);
  227. x25_enquiry_response(sk);
  228. } else {
  229. x25->condition |= X25_COND_ACK_PENDING;
  230. x25_start_t2timer(sk);
  231. }
  232. break;
  233. case X25_INTERRUPT_CONFIRMATION:
  234. x25->intflag = 0;
  235. break;
  236. case X25_INTERRUPT:
  237. if (sock_flag(sk, SOCK_URGINLINE))
  238. queued = !sock_queue_rcv_skb(sk, skb);
  239. else {
  240. skb_set_owner_r(skb, sk);
  241. skb_queue_tail(&x25->interrupt_in_queue, skb);
  242. queued = 1;
  243. }
  244. sk_send_sigurg(sk);
  245. x25_write_internal(sk, X25_INTERRUPT_CONFIRMATION);
  246. break;
  247. default:
  248. printk(KERN_WARNING "x25: unknown %02X in state 3\n", frametype);
  249. break;
  250. }
  251. return queued;
  252. }
  253. /*
  254. * State machine for state 4, Awaiting Reset Confirmation State.
  255. * The handling of the timer(s) is in file x25_timer.c
  256. * Handling of state 0 and connection release is in af_x25.c.
  257. */
  258. static int x25_state4_machine(struct sock *sk, struct sk_buff *skb, int frametype)
  259. {
  260. switch (frametype) {
  261. case X25_RESET_REQUEST:
  262. x25_write_internal(sk, X25_RESET_CONFIRMATION);
  263. case X25_RESET_CONFIRMATION: {
  264. struct x25_sock *x25 = x25_sk(sk);
  265. x25_stop_timer(sk);
  266. x25->condition = 0x00;
  267. x25->va = 0;
  268. x25->vr = 0;
  269. x25->vs = 0;
  270. x25->vl = 0;
  271. x25->state = X25_STATE_3;
  272. x25_requeue_frames(sk);
  273. break;
  274. }
  275. case X25_CLEAR_REQUEST:
  276. x25_write_internal(sk, X25_CLEAR_CONFIRMATION);
  277. x25_disconnect(sk, 0, skb->data[3], skb->data[4]);
  278. break;
  279. default:
  280. break;
  281. }
  282. return 0;
  283. }
  284. /* Higher level upcall for a LAPB frame */
  285. int x25_process_rx_frame(struct sock *sk, struct sk_buff *skb)
  286. {
  287. struct x25_sock *x25 = x25_sk(sk);
  288. int queued = 0, frametype, ns, nr, q, d, m;
  289. if (x25->state == X25_STATE_0)
  290. return 0;
  291. frametype = x25_decode(sk, skb, &ns, &nr, &q, &d, &m);
  292. switch (x25->state) {
  293. case X25_STATE_1:
  294. queued = x25_state1_machine(sk, skb, frametype);
  295. break;
  296. case X25_STATE_2:
  297. queued = x25_state2_machine(sk, skb, frametype);
  298. break;
  299. case X25_STATE_3:
  300. queued = x25_state3_machine(sk, skb, frametype, ns, nr, q, d, m);
  301. break;
  302. case X25_STATE_4:
  303. queued = x25_state4_machine(sk, skb, frametype);
  304. break;
  305. }
  306. x25_kick(sk);
  307. return queued;
  308. }
  309. int x25_backlog_rcv(struct sock *sk, struct sk_buff *skb)
  310. {
  311. int queued = x25_process_rx_frame(sk, skb);
  312. if (!queued)
  313. kfree_skb(skb);
  314. return 0;
  315. }