lapb_in.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723
  1. /*
  2. * LAPB release 002
  3. *
  4. * This code REQUIRES 2.1.15 or higher/ NET3.038
  5. *
  6. * This module:
  7. * This module is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU General Public License
  9. * as published by the Free Software Foundation; either version
  10. * 2 of the License, or (at your option) any later version.
  11. *
  12. * History
  13. * LAPB 001 Jonathan Naulor Started Coding
  14. * LAPB 002 Jonathan Naylor New timer architecture.
  15. * 2000-10-29 Henner Eisen lapb_data_indication() return status.
  16. */
  17. #include <linux/errno.h>
  18. #include <linux/types.h>
  19. #include <linux/socket.h>
  20. #include <linux/in.h>
  21. #include <linux/kernel.h>
  22. #include <linux/timer.h>
  23. #include <linux/string.h>
  24. #include <linux/sockios.h>
  25. #include <linux/net.h>
  26. #include <linux/inet.h>
  27. #include <linux/netdevice.h>
  28. #include <linux/skbuff.h>
  29. #include <net/sock.h>
  30. #include <asm/uaccess.h>
  31. #include <asm/system.h>
  32. #include <linux/fcntl.h>
  33. #include <linux/mm.h>
  34. #include <linux/interrupt.h>
  35. #include <net/lapb.h>
  36. /*
  37. * State machine for state 0, Disconnected State.
  38. * The handling of the timer(s) is in file lapb_timer.c.
  39. */
  40. static void lapb_state0_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  41. struct lapb_frame *frame)
  42. {
  43. switch (frame->type) {
  44. case LAPB_SABM:
  45. #if LAPB_DEBUG > 1
  46. printk(KERN_DEBUG "lapb: (%p) S0 RX SABM(%d)\n",
  47. lapb->dev, frame->pf);
  48. #endif
  49. if (lapb->mode & LAPB_EXTENDED) {
  50. #if LAPB_DEBUG > 1
  51. printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
  52. lapb->dev, frame->pf);
  53. #endif
  54. lapb_send_control(lapb, LAPB_DM, frame->pf,
  55. LAPB_RESPONSE);
  56. } else {
  57. #if LAPB_DEBUG > 1
  58. printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
  59. lapb->dev, frame->pf);
  60. #endif
  61. #if LAPB_DEBUG > 0
  62. printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n",
  63. lapb->dev);
  64. #endif
  65. lapb_send_control(lapb, LAPB_UA, frame->pf,
  66. LAPB_RESPONSE);
  67. lapb_stop_t1timer(lapb);
  68. lapb_stop_t2timer(lapb);
  69. lapb->state = LAPB_STATE_3;
  70. lapb->condition = 0x00;
  71. lapb->n2count = 0;
  72. lapb->vs = 0;
  73. lapb->vr = 0;
  74. lapb->va = 0;
  75. lapb_connect_indication(lapb, LAPB_OK);
  76. }
  77. break;
  78. case LAPB_SABME:
  79. #if LAPB_DEBUG > 1
  80. printk(KERN_DEBUG "lapb: (%p) S0 RX SABME(%d)\n",
  81. lapb->dev, frame->pf);
  82. #endif
  83. if (lapb->mode & LAPB_EXTENDED) {
  84. #if LAPB_DEBUG > 1
  85. printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
  86. lapb->dev, frame->pf);
  87. #endif
  88. #if LAPB_DEBUG > 0
  89. printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n",
  90. lapb->dev);
  91. #endif
  92. lapb_send_control(lapb, LAPB_UA, frame->pf,
  93. LAPB_RESPONSE);
  94. lapb_stop_t1timer(lapb);
  95. lapb_stop_t2timer(lapb);
  96. lapb->state = LAPB_STATE_3;
  97. lapb->condition = 0x00;
  98. lapb->n2count = 0;
  99. lapb->vs = 0;
  100. lapb->vr = 0;
  101. lapb->va = 0;
  102. lapb_connect_indication(lapb, LAPB_OK);
  103. } else {
  104. #if LAPB_DEBUG > 1
  105. printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
  106. lapb->dev, frame->pf);
  107. #endif
  108. lapb_send_control(lapb, LAPB_DM, frame->pf,
  109. LAPB_RESPONSE);
  110. }
  111. break;
  112. case LAPB_DISC:
  113. #if LAPB_DEBUG > 1
  114. printk(KERN_DEBUG "lapb: (%p) S0 RX DISC(%d)\n",
  115. lapb->dev, frame->pf);
  116. printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
  117. lapb->dev, frame->pf);
  118. #endif
  119. lapb_send_control(lapb, LAPB_UA, frame->pf,
  120. LAPB_RESPONSE);
  121. break;
  122. default:
  123. break;
  124. }
  125. kfree_skb(skb);
  126. }
  127. /*
  128. * State machine for state 1, Awaiting Connection State.
  129. * The handling of the timer(s) is in file lapb_timer.c.
  130. */
  131. static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  132. struct lapb_frame *frame)
  133. {
  134. switch (frame->type) {
  135. case LAPB_SABM:
  136. #if LAPB_DEBUG > 1
  137. printk(KERN_DEBUG "lapb: (%p) S1 RX SABM(%d)\n",
  138. lapb->dev, frame->pf);
  139. #endif
  140. if (lapb->mode & LAPB_EXTENDED) {
  141. #if LAPB_DEBUG > 1
  142. printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
  143. lapb->dev, frame->pf);
  144. #endif
  145. lapb_send_control(lapb, LAPB_DM, frame->pf,
  146. LAPB_RESPONSE);
  147. } else {
  148. #if LAPB_DEBUG > 1
  149. printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
  150. lapb->dev, frame->pf);
  151. #endif
  152. lapb_send_control(lapb, LAPB_UA, frame->pf,
  153. LAPB_RESPONSE);
  154. }
  155. break;
  156. case LAPB_SABME:
  157. #if LAPB_DEBUG > 1
  158. printk(KERN_DEBUG "lapb: (%p) S1 RX SABME(%d)\n",
  159. lapb->dev, frame->pf);
  160. #endif
  161. if (lapb->mode & LAPB_EXTENDED) {
  162. #if LAPB_DEBUG > 1
  163. printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
  164. lapb->dev, frame->pf);
  165. #endif
  166. lapb_send_control(lapb, LAPB_UA, frame->pf,
  167. LAPB_RESPONSE);
  168. } else {
  169. #if LAPB_DEBUG > 1
  170. printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
  171. lapb->dev, frame->pf);
  172. #endif
  173. lapb_send_control(lapb, LAPB_DM, frame->pf,
  174. LAPB_RESPONSE);
  175. }
  176. break;
  177. case LAPB_DISC:
  178. #if LAPB_DEBUG > 1
  179. printk(KERN_DEBUG "lapb: (%p) S1 RX DISC(%d)\n",
  180. lapb->dev, frame->pf);
  181. printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
  182. lapb->dev, frame->pf);
  183. #endif
  184. lapb_send_control(lapb, LAPB_DM, frame->pf,
  185. LAPB_RESPONSE);
  186. break;
  187. case LAPB_UA:
  188. #if LAPB_DEBUG > 1
  189. printk(KERN_DEBUG "lapb: (%p) S1 RX UA(%d)\n",
  190. lapb->dev, frame->pf);
  191. #endif
  192. if (frame->pf) {
  193. #if LAPB_DEBUG > 0
  194. printk(KERN_DEBUG "lapb: (%p) S1 -> S3\n",
  195. lapb->dev);
  196. #endif
  197. lapb_stop_t1timer(lapb);
  198. lapb_stop_t2timer(lapb);
  199. lapb->state = LAPB_STATE_3;
  200. lapb->condition = 0x00;
  201. lapb->n2count = 0;
  202. lapb->vs = 0;
  203. lapb->vr = 0;
  204. lapb->va = 0;
  205. lapb_connect_confirmation(lapb, LAPB_OK);
  206. }
  207. break;
  208. case LAPB_DM:
  209. #if LAPB_DEBUG > 1
  210. printk(KERN_DEBUG "lapb: (%p) S1 RX DM(%d)\n",
  211. lapb->dev, frame->pf);
  212. #endif
  213. if (frame->pf) {
  214. #if LAPB_DEBUG > 0
  215. printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n",
  216. lapb->dev);
  217. #endif
  218. lapb_clear_queues(lapb);
  219. lapb->state = LAPB_STATE_0;
  220. lapb_start_t1timer(lapb);
  221. lapb_stop_t2timer(lapb);
  222. lapb_disconnect_indication(lapb, LAPB_REFUSED);
  223. }
  224. break;
  225. }
  226. kfree_skb(skb);
  227. }
  228. /*
  229. * State machine for state 2, Awaiting Release State.
  230. * The handling of the timer(s) is in file lapb_timer.c
  231. */
  232. static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  233. struct lapb_frame *frame)
  234. {
  235. switch (frame->type) {
  236. case LAPB_SABM:
  237. case LAPB_SABME:
  238. #if LAPB_DEBUG > 1
  239. printk(KERN_DEBUG "lapb: (%p) S2 RX {SABM,SABME}(%d)\n",
  240. lapb->dev, frame->pf);
  241. printk(KERN_DEBUG "lapb: (%p) S2 TX DM(%d)\n",
  242. lapb->dev, frame->pf);
  243. #endif
  244. lapb_send_control(lapb, LAPB_DM, frame->pf,
  245. LAPB_RESPONSE);
  246. break;
  247. case LAPB_DISC:
  248. #if LAPB_DEBUG > 1
  249. printk(KERN_DEBUG "lapb: (%p) S2 RX DISC(%d)\n",
  250. lapb->dev, frame->pf);
  251. printk(KERN_DEBUG "lapb: (%p) S2 TX UA(%d)\n",
  252. lapb->dev, frame->pf);
  253. #endif
  254. lapb_send_control(lapb, LAPB_UA, frame->pf,
  255. LAPB_RESPONSE);
  256. break;
  257. case LAPB_UA:
  258. #if LAPB_DEBUG > 1
  259. printk(KERN_DEBUG "lapb: (%p) S2 RX UA(%d)\n",
  260. lapb->dev, frame->pf);
  261. #endif
  262. if (frame->pf) {
  263. #if LAPB_DEBUG > 0
  264. printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n",
  265. lapb->dev);
  266. #endif
  267. lapb->state = LAPB_STATE_0;
  268. lapb_start_t1timer(lapb);
  269. lapb_stop_t2timer(lapb);
  270. lapb_disconnect_confirmation(lapb, LAPB_OK);
  271. }
  272. break;
  273. case LAPB_DM:
  274. #if LAPB_DEBUG > 1
  275. printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
  276. lapb->dev, frame->pf);
  277. #endif
  278. if (frame->pf) {
  279. #if LAPB_DEBUG > 0
  280. printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n",
  281. lapb->dev);
  282. #endif
  283. lapb->state = LAPB_STATE_0;
  284. lapb_start_t1timer(lapb);
  285. lapb_stop_t2timer(lapb);
  286. lapb_disconnect_confirmation(lapb,
  287. LAPB_NOTCONNECTED);
  288. }
  289. break;
  290. case LAPB_I:
  291. case LAPB_REJ:
  292. case LAPB_RNR:
  293. case LAPB_RR:
  294. #if LAPB_DEBUG > 1
  295. printk(KERN_DEBUG "lapb: (%p) S2 RX {I,REJ,RNR,RR}"
  296. "(%d)\n", lapb->dev, frame->pf);
  297. printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
  298. lapb->dev, frame->pf);
  299. #endif
  300. if (frame->pf)
  301. lapb_send_control(lapb, LAPB_DM, frame->pf,
  302. LAPB_RESPONSE);
  303. break;
  304. }
  305. kfree_skb(skb);
  306. }
  307. /*
  308. * State machine for state 3, Connected State.
  309. * The handling of the timer(s) is in file lapb_timer.c
  310. */
  311. static void lapb_state3_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  312. struct lapb_frame *frame)
  313. {
  314. int queued = 0;
  315. int modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS :
  316. LAPB_SMODULUS;
  317. switch (frame->type) {
  318. case LAPB_SABM:
  319. #if LAPB_DEBUG > 1
  320. printk(KERN_DEBUG "lapb: (%p) S3 RX SABM(%d)\n",
  321. lapb->dev, frame->pf);
  322. #endif
  323. if (lapb->mode & LAPB_EXTENDED) {
  324. #if LAPB_DEBUG > 1
  325. printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
  326. lapb->dev, frame->pf);
  327. #endif
  328. lapb_send_control(lapb, LAPB_DM, frame->pf,
  329. LAPB_RESPONSE);
  330. } else {
  331. #if LAPB_DEBUG > 1
  332. printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
  333. lapb->dev, frame->pf);
  334. #endif
  335. lapb_send_control(lapb, LAPB_UA, frame->pf,
  336. LAPB_RESPONSE);
  337. lapb_stop_t1timer(lapb);
  338. lapb_stop_t2timer(lapb);
  339. lapb->condition = 0x00;
  340. lapb->n2count = 0;
  341. lapb->vs = 0;
  342. lapb->vr = 0;
  343. lapb->va = 0;
  344. lapb_requeue_frames(lapb);
  345. }
  346. break;
  347. case LAPB_SABME:
  348. #if LAPB_DEBUG > 1
  349. printk(KERN_DEBUG "lapb: (%p) S3 RX SABME(%d)\n",
  350. lapb->dev, frame->pf);
  351. #endif
  352. if (lapb->mode & LAPB_EXTENDED) {
  353. #if LAPB_DEBUG > 1
  354. printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
  355. lapb->dev, frame->pf);
  356. #endif
  357. lapb_send_control(lapb, LAPB_UA, frame->pf,
  358. LAPB_RESPONSE);
  359. lapb_stop_t1timer(lapb);
  360. lapb_stop_t2timer(lapb);
  361. lapb->condition = 0x00;
  362. lapb->n2count = 0;
  363. lapb->vs = 0;
  364. lapb->vr = 0;
  365. lapb->va = 0;
  366. lapb_requeue_frames(lapb);
  367. } else {
  368. #if LAPB_DEBUG > 1
  369. printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
  370. lapb->dev, frame->pf);
  371. #endif
  372. lapb_send_control(lapb, LAPB_DM, frame->pf,
  373. LAPB_RESPONSE);
  374. }
  375. break;
  376. case LAPB_DISC:
  377. #if LAPB_DEBUG > 1
  378. printk(KERN_DEBUG "lapb: (%p) S3 RX DISC(%d)\n",
  379. lapb->dev, frame->pf);
  380. #endif
  381. #if LAPB_DEBUG > 0
  382. printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n",
  383. lapb->dev);
  384. #endif
  385. lapb_clear_queues(lapb);
  386. lapb_send_control(lapb, LAPB_UA, frame->pf,
  387. LAPB_RESPONSE);
  388. lapb_start_t1timer(lapb);
  389. lapb_stop_t2timer(lapb);
  390. lapb->state = LAPB_STATE_0;
  391. lapb_disconnect_indication(lapb, LAPB_OK);
  392. break;
  393. case LAPB_DM:
  394. #if LAPB_DEBUG > 1
  395. printk(KERN_DEBUG "lapb: (%p) S3 RX DM(%d)\n",
  396. lapb->dev, frame->pf);
  397. #endif
  398. #if LAPB_DEBUG > 0
  399. printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n",
  400. lapb->dev);
  401. #endif
  402. lapb_clear_queues(lapb);
  403. lapb->state = LAPB_STATE_0;
  404. lapb_start_t1timer(lapb);
  405. lapb_stop_t2timer(lapb);
  406. lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED);
  407. break;
  408. case LAPB_RNR:
  409. #if LAPB_DEBUG > 1
  410. printk(KERN_DEBUG "lapb: (%p) S3 RX RNR(%d) R%d\n",
  411. lapb->dev, frame->pf, frame->nr);
  412. #endif
  413. lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION;
  414. lapb_check_need_response(lapb, frame->cr, frame->pf);
  415. if (lapb_validate_nr(lapb, frame->nr)) {
  416. lapb_check_iframes_acked(lapb, frame->nr);
  417. } else {
  418. lapb->frmr_data = *frame;
  419. lapb->frmr_type = LAPB_FRMR_Z;
  420. lapb_transmit_frmr(lapb);
  421. #if LAPB_DEBUG > 0
  422. printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
  423. lapb->dev);
  424. #endif
  425. lapb_start_t1timer(lapb);
  426. lapb_stop_t2timer(lapb);
  427. lapb->state = LAPB_STATE_4;
  428. lapb->n2count = 0;
  429. }
  430. break;
  431. case LAPB_RR:
  432. #if LAPB_DEBUG > 1
  433. printk(KERN_DEBUG "lapb: (%p) S3 RX RR(%d) R%d\n",
  434. lapb->dev, frame->pf, frame->nr);
  435. #endif
  436. lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
  437. lapb_check_need_response(lapb, frame->cr, frame->pf);
  438. if (lapb_validate_nr(lapb, frame->nr)) {
  439. lapb_check_iframes_acked(lapb, frame->nr);
  440. } else {
  441. lapb->frmr_data = *frame;
  442. lapb->frmr_type = LAPB_FRMR_Z;
  443. lapb_transmit_frmr(lapb);
  444. #if LAPB_DEBUG > 0
  445. printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
  446. lapb->dev);
  447. #endif
  448. lapb_start_t1timer(lapb);
  449. lapb_stop_t2timer(lapb);
  450. lapb->state = LAPB_STATE_4;
  451. lapb->n2count = 0;
  452. }
  453. break;
  454. case LAPB_REJ:
  455. #if LAPB_DEBUG > 1
  456. printk(KERN_DEBUG "lapb: (%p) S3 RX REJ(%d) R%d\n",
  457. lapb->dev, frame->pf, frame->nr);
  458. #endif
  459. lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
  460. lapb_check_need_response(lapb, frame->cr, frame->pf);
  461. if (lapb_validate_nr(lapb, frame->nr)) {
  462. lapb_frames_acked(lapb, frame->nr);
  463. lapb_stop_t1timer(lapb);
  464. lapb->n2count = 0;
  465. lapb_requeue_frames(lapb);
  466. } else {
  467. lapb->frmr_data = *frame;
  468. lapb->frmr_type = LAPB_FRMR_Z;
  469. lapb_transmit_frmr(lapb);
  470. #if LAPB_DEBUG > 0
  471. printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
  472. lapb->dev);
  473. #endif
  474. lapb_start_t1timer(lapb);
  475. lapb_stop_t2timer(lapb);
  476. lapb->state = LAPB_STATE_4;
  477. lapb->n2count = 0;
  478. }
  479. break;
  480. case LAPB_I:
  481. #if LAPB_DEBUG > 1
  482. printk(KERN_DEBUG "lapb: (%p) S3 RX I(%d) S%d R%d\n",
  483. lapb->dev, frame->pf, frame->ns, frame->nr);
  484. #endif
  485. if (!lapb_validate_nr(lapb, frame->nr)) {
  486. lapb->frmr_data = *frame;
  487. lapb->frmr_type = LAPB_FRMR_Z;
  488. lapb_transmit_frmr(lapb);
  489. #if LAPB_DEBUG > 0
  490. printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
  491. lapb->dev);
  492. #endif
  493. lapb_start_t1timer(lapb);
  494. lapb_stop_t2timer(lapb);
  495. lapb->state = LAPB_STATE_4;
  496. lapb->n2count = 0;
  497. break;
  498. }
  499. if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION)
  500. lapb_frames_acked(lapb, frame->nr);
  501. else
  502. lapb_check_iframes_acked(lapb, frame->nr);
  503. if (frame->ns == lapb->vr) {
  504. int cn;
  505. cn = lapb_data_indication(lapb, skb);
  506. queued = 1;
  507. /*
  508. * If upper layer has dropped the frame, we
  509. * basically ignore any further protocol
  510. * processing. This will cause the peer
  511. * to re-transmit the frame later like
  512. * a frame lost on the wire.
  513. */
  514. if (cn == NET_RX_DROP) {
  515. printk(KERN_DEBUG
  516. "LAPB: rx congestion\n");
  517. break;
  518. }
  519. lapb->vr = (lapb->vr + 1) % modulus;
  520. lapb->condition &= ~LAPB_REJECT_CONDITION;
  521. if (frame->pf)
  522. lapb_enquiry_response(lapb);
  523. else {
  524. if (!(lapb->condition &
  525. LAPB_ACK_PENDING_CONDITION)) {
  526. lapb->condition |= LAPB_ACK_PENDING_CONDITION;
  527. lapb_start_t2timer(lapb);
  528. }
  529. }
  530. } else {
  531. if (lapb->condition & LAPB_REJECT_CONDITION) {
  532. if (frame->pf)
  533. lapb_enquiry_response(lapb);
  534. } else {
  535. #if LAPB_DEBUG > 1
  536. printk(KERN_DEBUG
  537. "lapb: (%p) S3 TX REJ(%d) R%d\n",
  538. lapb->dev, frame->pf, lapb->vr);
  539. #endif
  540. lapb->condition |= LAPB_REJECT_CONDITION;
  541. lapb_send_control(lapb, LAPB_REJ,
  542. frame->pf,
  543. LAPB_RESPONSE);
  544. lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
  545. }
  546. }
  547. break;
  548. case LAPB_FRMR:
  549. #if LAPB_DEBUG > 1
  550. printk(KERN_DEBUG "lapb: (%p) S3 RX FRMR(%d) %02X "
  551. "%02X %02X %02X %02X\n", lapb->dev, frame->pf,
  552. skb->data[0], skb->data[1], skb->data[2],
  553. skb->data[3], skb->data[4]);
  554. #endif
  555. lapb_establish_data_link(lapb);
  556. #if LAPB_DEBUG > 0
  557. printk(KERN_DEBUG "lapb: (%p) S3 -> S1\n",
  558. lapb->dev);
  559. #endif
  560. lapb_requeue_frames(lapb);
  561. lapb->state = LAPB_STATE_1;
  562. break;
  563. case LAPB_ILLEGAL:
  564. #if LAPB_DEBUG > 1
  565. printk(KERN_DEBUG "lapb: (%p) S3 RX ILLEGAL(%d)\n",
  566. lapb->dev, frame->pf);
  567. #endif
  568. lapb->frmr_data = *frame;
  569. lapb->frmr_type = LAPB_FRMR_W;
  570. lapb_transmit_frmr(lapb);
  571. #if LAPB_DEBUG > 0
  572. printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
  573. #endif
  574. lapb_start_t1timer(lapb);
  575. lapb_stop_t2timer(lapb);
  576. lapb->state = LAPB_STATE_4;
  577. lapb->n2count = 0;
  578. break;
  579. }
  580. if (!queued)
  581. kfree_skb(skb);
  582. }
  583. /*
  584. * State machine for state 4, Frame Reject State.
  585. * The handling of the timer(s) is in file lapb_timer.c.
  586. */
  587. static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  588. struct lapb_frame *frame)
  589. {
  590. switch (frame->type) {
  591. case LAPB_SABM:
  592. #if LAPB_DEBUG > 1
  593. printk(KERN_DEBUG "lapb: (%p) S4 RX SABM(%d)\n",
  594. lapb->dev, frame->pf);
  595. #endif
  596. if (lapb->mode & LAPB_EXTENDED) {
  597. #if LAPB_DEBUG > 1
  598. printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
  599. lapb->dev, frame->pf);
  600. #endif
  601. lapb_send_control(lapb, LAPB_DM, frame->pf,
  602. LAPB_RESPONSE);
  603. } else {
  604. #if LAPB_DEBUG > 1
  605. printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
  606. lapb->dev, frame->pf);
  607. #endif
  608. #if LAPB_DEBUG > 0
  609. printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n",
  610. lapb->dev);
  611. #endif
  612. lapb_send_control(lapb, LAPB_UA, frame->pf,
  613. LAPB_RESPONSE);
  614. lapb_stop_t1timer(lapb);
  615. lapb_stop_t2timer(lapb);
  616. lapb->state = LAPB_STATE_3;
  617. lapb->condition = 0x00;
  618. lapb->n2count = 0;
  619. lapb->vs = 0;
  620. lapb->vr = 0;
  621. lapb->va = 0;
  622. lapb_connect_indication(lapb, LAPB_OK);
  623. }
  624. break;
  625. case LAPB_SABME:
  626. #if LAPB_DEBUG > 1
  627. printk(KERN_DEBUG "lapb: (%p) S4 RX SABME(%d)\n",
  628. lapb->dev, frame->pf);
  629. #endif
  630. if (lapb->mode & LAPB_EXTENDED) {
  631. #if LAPB_DEBUG > 1
  632. printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
  633. lapb->dev, frame->pf);
  634. #endif
  635. #if LAPB_DEBUG > 0
  636. printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n",
  637. lapb->dev);
  638. #endif
  639. lapb_send_control(lapb, LAPB_UA, frame->pf,
  640. LAPB_RESPONSE);
  641. lapb_stop_t1timer(lapb);
  642. lapb_stop_t2timer(lapb);
  643. lapb->state = LAPB_STATE_3;
  644. lapb->condition = 0x00;
  645. lapb->n2count = 0;
  646. lapb->vs = 0;
  647. lapb->vr = 0;
  648. lapb->va = 0;
  649. lapb_connect_indication(lapb, LAPB_OK);
  650. } else {
  651. #if LAPB_DEBUG > 1
  652. printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
  653. lapb->dev, frame->pf);
  654. #endif
  655. lapb_send_control(lapb, LAPB_DM, frame->pf,
  656. LAPB_RESPONSE);
  657. }
  658. break;
  659. }
  660. kfree_skb(skb);
  661. }
  662. /*
  663. * Process an incoming LAPB frame
  664. */
  665. void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *skb)
  666. {
  667. struct lapb_frame frame;
  668. if (lapb_decode(lapb, skb, &frame) < 0) {
  669. kfree_skb(skb);
  670. return;
  671. }
  672. switch (lapb->state) {
  673. case LAPB_STATE_0:
  674. lapb_state0_machine(lapb, skb, &frame); break;
  675. case LAPB_STATE_1:
  676. lapb_state1_machine(lapb, skb, &frame); break;
  677. case LAPB_STATE_2:
  678. lapb_state2_machine(lapb, skb, &frame); break;
  679. case LAPB_STATE_3:
  680. lapb_state3_machine(lapb, skb, &frame); break;
  681. case LAPB_STATE_4:
  682. lapb_state4_machine(lapb, skb, &frame); break;
  683. }
  684. lapb_kick(lapb);
  685. }