lapb_in.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * LAPB release 002
  4. *
  5. * This code REQUIRES 2.1.15 or higher/ NET3.038
  6. *
  7. * History
  8. * LAPB 001 Jonathan Naulor Started Coding
  9. * LAPB 002 Jonathan Naylor New timer architecture.
  10. * 2000-10-29 Henner Eisen lapb_data_indication() return status.
  11. */
  12. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13. #include <linux/errno.h>
  14. #include <linux/types.h>
  15. #include <linux/socket.h>
  16. #include <linux/in.h>
  17. #include <linux/kernel.h>
  18. #include <linux/timer.h>
  19. #include <linux/string.h>
  20. #include <linux/sockios.h>
  21. #include <linux/net.h>
  22. #include <linux/inet.h>
  23. #include <linux/netdevice.h>
  24. #include <linux/skbuff.h>
  25. #include <linux/slab.h>
  26. #include <net/sock.h>
  27. #include <linux/uaccess.h>
  28. #include <linux/fcntl.h>
  29. #include <linux/mm.h>
  30. #include <linux/interrupt.h>
  31. #include <net/lapb.h>
  32. /*
  33. * State machine for state 0, Disconnected State.
  34. * The handling of the timer(s) is in file lapb_timer.c.
  35. */
  36. static void lapb_state0_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  37. struct lapb_frame *frame)
  38. {
  39. switch (frame->type) {
  40. case LAPB_SABM:
  41. lapb_dbg(1, "(%p) S0 RX SABM(%d)\n", lapb->dev, frame->pf);
  42. if (lapb->mode & LAPB_EXTENDED) {
  43. lapb_dbg(1, "(%p) S0 TX DM(%d)\n",
  44. lapb->dev, frame->pf);
  45. lapb_send_control(lapb, LAPB_DM, frame->pf,
  46. LAPB_RESPONSE);
  47. } else {
  48. lapb_dbg(1, "(%p) S0 TX UA(%d)\n",
  49. lapb->dev, frame->pf);
  50. lapb_dbg(0, "(%p) S0 -> S3\n", lapb->dev);
  51. lapb_send_control(lapb, LAPB_UA, frame->pf,
  52. LAPB_RESPONSE);
  53. lapb_stop_t1timer(lapb);
  54. lapb_stop_t2timer(lapb);
  55. lapb->state = LAPB_STATE_3;
  56. lapb->condition = 0x00;
  57. lapb->n2count = 0;
  58. lapb->vs = 0;
  59. lapb->vr = 0;
  60. lapb->va = 0;
  61. lapb_connect_indication(lapb, LAPB_OK);
  62. }
  63. break;
  64. case LAPB_SABME:
  65. lapb_dbg(1, "(%p) S0 RX SABME(%d)\n", lapb->dev, frame->pf);
  66. if (lapb->mode & LAPB_EXTENDED) {
  67. lapb_dbg(1, "(%p) S0 TX UA(%d)\n",
  68. lapb->dev, frame->pf);
  69. lapb_dbg(0, "(%p) S0 -> S3\n", lapb->dev);
  70. lapb_send_control(lapb, LAPB_UA, frame->pf,
  71. LAPB_RESPONSE);
  72. lapb_stop_t1timer(lapb);
  73. lapb_stop_t2timer(lapb);
  74. lapb->state = LAPB_STATE_3;
  75. lapb->condition = 0x00;
  76. lapb->n2count = 0;
  77. lapb->vs = 0;
  78. lapb->vr = 0;
  79. lapb->va = 0;
  80. lapb_connect_indication(lapb, LAPB_OK);
  81. } else {
  82. lapb_dbg(1, "(%p) S0 TX DM(%d)\n",
  83. lapb->dev, frame->pf);
  84. lapb_send_control(lapb, LAPB_DM, frame->pf,
  85. LAPB_RESPONSE);
  86. }
  87. break;
  88. case LAPB_DISC:
  89. lapb_dbg(1, "(%p) S0 RX DISC(%d)\n", lapb->dev, frame->pf);
  90. lapb_dbg(1, "(%p) S0 TX UA(%d)\n", lapb->dev, frame->pf);
  91. lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
  92. break;
  93. default:
  94. break;
  95. }
  96. kfree_skb(skb);
  97. }
  98. /*
  99. * State machine for state 1, Awaiting Connection State.
  100. * The handling of the timer(s) is in file lapb_timer.c.
  101. */
  102. static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  103. struct lapb_frame *frame)
  104. {
  105. switch (frame->type) {
  106. case LAPB_SABM:
  107. lapb_dbg(1, "(%p) S1 RX SABM(%d)\n", lapb->dev, frame->pf);
  108. if (lapb->mode & LAPB_EXTENDED) {
  109. lapb_dbg(1, "(%p) S1 TX DM(%d)\n",
  110. lapb->dev, frame->pf);
  111. lapb_send_control(lapb, LAPB_DM, frame->pf,
  112. LAPB_RESPONSE);
  113. } else {
  114. lapb_dbg(1, "(%p) S1 TX UA(%d)\n",
  115. lapb->dev, frame->pf);
  116. lapb_send_control(lapb, LAPB_UA, frame->pf,
  117. LAPB_RESPONSE);
  118. }
  119. break;
  120. case LAPB_SABME:
  121. lapb_dbg(1, "(%p) S1 RX SABME(%d)\n", lapb->dev, frame->pf);
  122. if (lapb->mode & LAPB_EXTENDED) {
  123. lapb_dbg(1, "(%p) S1 TX UA(%d)\n",
  124. lapb->dev, frame->pf);
  125. lapb_send_control(lapb, LAPB_UA, frame->pf,
  126. LAPB_RESPONSE);
  127. } else {
  128. lapb_dbg(1, "(%p) S1 TX DM(%d)\n",
  129. lapb->dev, frame->pf);
  130. lapb_send_control(lapb, LAPB_DM, frame->pf,
  131. LAPB_RESPONSE);
  132. }
  133. break;
  134. case LAPB_DISC:
  135. lapb_dbg(1, "(%p) S1 RX DISC(%d)\n", lapb->dev, frame->pf);
  136. lapb_dbg(1, "(%p) S1 TX DM(%d)\n", lapb->dev, frame->pf);
  137. lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
  138. break;
  139. case LAPB_UA:
  140. lapb_dbg(1, "(%p) S1 RX UA(%d)\n", lapb->dev, frame->pf);
  141. if (frame->pf) {
  142. lapb_dbg(0, "(%p) S1 -> S3\n", lapb->dev);
  143. lapb_stop_t1timer(lapb);
  144. lapb_stop_t2timer(lapb);
  145. lapb->state = LAPB_STATE_3;
  146. lapb->condition = 0x00;
  147. lapb->n2count = 0;
  148. lapb->vs = 0;
  149. lapb->vr = 0;
  150. lapb->va = 0;
  151. lapb_connect_confirmation(lapb, LAPB_OK);
  152. }
  153. break;
  154. case LAPB_DM:
  155. lapb_dbg(1, "(%p) S1 RX DM(%d)\n", lapb->dev, frame->pf);
  156. if (frame->pf) {
  157. lapb_dbg(0, "(%p) S1 -> S0\n", lapb->dev);
  158. lapb_clear_queues(lapb);
  159. lapb->state = LAPB_STATE_0;
  160. lapb_start_t1timer(lapb);
  161. lapb_stop_t2timer(lapb);
  162. lapb_disconnect_indication(lapb, LAPB_REFUSED);
  163. }
  164. break;
  165. }
  166. kfree_skb(skb);
  167. }
  168. /*
  169. * State machine for state 2, Awaiting Release State.
  170. * The handling of the timer(s) is in file lapb_timer.c
  171. */
  172. static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  173. struct lapb_frame *frame)
  174. {
  175. switch (frame->type) {
  176. case LAPB_SABM:
  177. case LAPB_SABME:
  178. lapb_dbg(1, "(%p) S2 RX {SABM,SABME}(%d)\n",
  179. lapb->dev, frame->pf);
  180. lapb_dbg(1, "(%p) S2 TX DM(%d)\n", lapb->dev, frame->pf);
  181. lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
  182. break;
  183. case LAPB_DISC:
  184. lapb_dbg(1, "(%p) S2 RX DISC(%d)\n", lapb->dev, frame->pf);
  185. lapb_dbg(1, "(%p) S2 TX UA(%d)\n", lapb->dev, frame->pf);
  186. lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
  187. break;
  188. case LAPB_UA:
  189. lapb_dbg(1, "(%p) S2 RX UA(%d)\n", lapb->dev, frame->pf);
  190. if (frame->pf) {
  191. lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev);
  192. lapb->state = LAPB_STATE_0;
  193. lapb_start_t1timer(lapb);
  194. lapb_stop_t2timer(lapb);
  195. lapb_disconnect_confirmation(lapb, LAPB_OK);
  196. }
  197. break;
  198. case LAPB_DM:
  199. lapb_dbg(1, "(%p) S2 RX DM(%d)\n", lapb->dev, frame->pf);
  200. if (frame->pf) {
  201. lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev);
  202. lapb->state = LAPB_STATE_0;
  203. lapb_start_t1timer(lapb);
  204. lapb_stop_t2timer(lapb);
  205. lapb_disconnect_confirmation(lapb, LAPB_NOTCONNECTED);
  206. }
  207. break;
  208. case LAPB_I:
  209. case LAPB_REJ:
  210. case LAPB_RNR:
  211. case LAPB_RR:
  212. lapb_dbg(1, "(%p) S2 RX {I,REJ,RNR,RR}(%d)\n",
  213. lapb->dev, frame->pf);
  214. lapb_dbg(1, "(%p) S2 RX DM(%d)\n", lapb->dev, frame->pf);
  215. if (frame->pf)
  216. lapb_send_control(lapb, LAPB_DM, frame->pf,
  217. LAPB_RESPONSE);
  218. break;
  219. }
  220. kfree_skb(skb);
  221. }
  222. /*
  223. * State machine for state 3, Connected State.
  224. * The handling of the timer(s) is in file lapb_timer.c
  225. */
  226. static void lapb_state3_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  227. struct lapb_frame *frame)
  228. {
  229. int queued = 0;
  230. int modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS :
  231. LAPB_SMODULUS;
  232. switch (frame->type) {
  233. case LAPB_SABM:
  234. lapb_dbg(1, "(%p) S3 RX SABM(%d)\n", lapb->dev, frame->pf);
  235. if (lapb->mode & LAPB_EXTENDED) {
  236. lapb_dbg(1, "(%p) S3 TX DM(%d)\n",
  237. lapb->dev, frame->pf);
  238. lapb_send_control(lapb, LAPB_DM, frame->pf,
  239. LAPB_RESPONSE);
  240. } else {
  241. lapb_dbg(1, "(%p) S3 TX UA(%d)\n",
  242. lapb->dev, frame->pf);
  243. lapb_send_control(lapb, LAPB_UA, frame->pf,
  244. LAPB_RESPONSE);
  245. lapb_stop_t1timer(lapb);
  246. lapb_stop_t2timer(lapb);
  247. lapb->condition = 0x00;
  248. lapb->n2count = 0;
  249. lapb->vs = 0;
  250. lapb->vr = 0;
  251. lapb->va = 0;
  252. lapb_requeue_frames(lapb);
  253. }
  254. break;
  255. case LAPB_SABME:
  256. lapb_dbg(1, "(%p) S3 RX SABME(%d)\n", lapb->dev, frame->pf);
  257. if (lapb->mode & LAPB_EXTENDED) {
  258. lapb_dbg(1, "(%p) S3 TX UA(%d)\n",
  259. lapb->dev, frame->pf);
  260. lapb_send_control(lapb, LAPB_UA, frame->pf,
  261. LAPB_RESPONSE);
  262. lapb_stop_t1timer(lapb);
  263. lapb_stop_t2timer(lapb);
  264. lapb->condition = 0x00;
  265. lapb->n2count = 0;
  266. lapb->vs = 0;
  267. lapb->vr = 0;
  268. lapb->va = 0;
  269. lapb_requeue_frames(lapb);
  270. } else {
  271. lapb_dbg(1, "(%p) S3 TX DM(%d)\n",
  272. lapb->dev, frame->pf);
  273. lapb_send_control(lapb, LAPB_DM, frame->pf,
  274. LAPB_RESPONSE);
  275. }
  276. break;
  277. case LAPB_DISC:
  278. lapb_dbg(1, "(%p) S3 RX DISC(%d)\n", lapb->dev, frame->pf);
  279. lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev);
  280. lapb_clear_queues(lapb);
  281. lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
  282. lapb_start_t1timer(lapb);
  283. lapb_stop_t2timer(lapb);
  284. lapb->state = LAPB_STATE_0;
  285. lapb_disconnect_indication(lapb, LAPB_OK);
  286. break;
  287. case LAPB_DM:
  288. lapb_dbg(1, "(%p) S3 RX DM(%d)\n", lapb->dev, frame->pf);
  289. lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev);
  290. lapb_clear_queues(lapb);
  291. lapb->state = LAPB_STATE_0;
  292. lapb_start_t1timer(lapb);
  293. lapb_stop_t2timer(lapb);
  294. lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED);
  295. break;
  296. case LAPB_RNR:
  297. lapb_dbg(1, "(%p) S3 RX RNR(%d) R%d\n",
  298. lapb->dev, frame->pf, frame->nr);
  299. lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION;
  300. lapb_check_need_response(lapb, frame->cr, frame->pf);
  301. if (lapb_validate_nr(lapb, frame->nr)) {
  302. lapb_check_iframes_acked(lapb, frame->nr);
  303. } else {
  304. lapb->frmr_data = *frame;
  305. lapb->frmr_type = LAPB_FRMR_Z;
  306. lapb_transmit_frmr(lapb);
  307. lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
  308. lapb_start_t1timer(lapb);
  309. lapb_stop_t2timer(lapb);
  310. lapb->state = LAPB_STATE_4;
  311. lapb->n2count = 0;
  312. }
  313. break;
  314. case LAPB_RR:
  315. lapb_dbg(1, "(%p) S3 RX RR(%d) R%d\n",
  316. lapb->dev, frame->pf, frame->nr);
  317. lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
  318. lapb_check_need_response(lapb, frame->cr, frame->pf);
  319. if (lapb_validate_nr(lapb, frame->nr)) {
  320. lapb_check_iframes_acked(lapb, frame->nr);
  321. } else {
  322. lapb->frmr_data = *frame;
  323. lapb->frmr_type = LAPB_FRMR_Z;
  324. lapb_transmit_frmr(lapb);
  325. lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
  326. lapb_start_t1timer(lapb);
  327. lapb_stop_t2timer(lapb);
  328. lapb->state = LAPB_STATE_4;
  329. lapb->n2count = 0;
  330. }
  331. break;
  332. case LAPB_REJ:
  333. lapb_dbg(1, "(%p) S3 RX REJ(%d) R%d\n",
  334. lapb->dev, frame->pf, frame->nr);
  335. lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
  336. lapb_check_need_response(lapb, frame->cr, frame->pf);
  337. if (lapb_validate_nr(lapb, frame->nr)) {
  338. lapb_frames_acked(lapb, frame->nr);
  339. lapb_stop_t1timer(lapb);
  340. lapb->n2count = 0;
  341. lapb_requeue_frames(lapb);
  342. } else {
  343. lapb->frmr_data = *frame;
  344. lapb->frmr_type = LAPB_FRMR_Z;
  345. lapb_transmit_frmr(lapb);
  346. lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
  347. lapb_start_t1timer(lapb);
  348. lapb_stop_t2timer(lapb);
  349. lapb->state = LAPB_STATE_4;
  350. lapb->n2count = 0;
  351. }
  352. break;
  353. case LAPB_I:
  354. lapb_dbg(1, "(%p) S3 RX I(%d) S%d R%d\n",
  355. lapb->dev, frame->pf, frame->ns, frame->nr);
  356. if (!lapb_validate_nr(lapb, frame->nr)) {
  357. lapb->frmr_data = *frame;
  358. lapb->frmr_type = LAPB_FRMR_Z;
  359. lapb_transmit_frmr(lapb);
  360. lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
  361. lapb_start_t1timer(lapb);
  362. lapb_stop_t2timer(lapb);
  363. lapb->state = LAPB_STATE_4;
  364. lapb->n2count = 0;
  365. break;
  366. }
  367. if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION)
  368. lapb_frames_acked(lapb, frame->nr);
  369. else
  370. lapb_check_iframes_acked(lapb, frame->nr);
  371. if (frame->ns == lapb->vr) {
  372. int cn;
  373. cn = lapb_data_indication(lapb, skb);
  374. queued = 1;
  375. /*
  376. * If upper layer has dropped the frame, we
  377. * basically ignore any further protocol
  378. * processing. This will cause the peer
  379. * to re-transmit the frame later like
  380. * a frame lost on the wire.
  381. */
  382. if (cn == NET_RX_DROP) {
  383. pr_debug("rx congestion\n");
  384. break;
  385. }
  386. lapb->vr = (lapb->vr + 1) % modulus;
  387. lapb->condition &= ~LAPB_REJECT_CONDITION;
  388. if (frame->pf)
  389. lapb_enquiry_response(lapb);
  390. else {
  391. if (!(lapb->condition &
  392. LAPB_ACK_PENDING_CONDITION)) {
  393. lapb->condition |= LAPB_ACK_PENDING_CONDITION;
  394. lapb_start_t2timer(lapb);
  395. }
  396. }
  397. } else {
  398. if (lapb->condition & LAPB_REJECT_CONDITION) {
  399. if (frame->pf)
  400. lapb_enquiry_response(lapb);
  401. } else {
  402. lapb_dbg(1, "(%p) S3 TX REJ(%d) R%d\n",
  403. lapb->dev, frame->pf, lapb->vr);
  404. lapb->condition |= LAPB_REJECT_CONDITION;
  405. lapb_send_control(lapb, LAPB_REJ, frame->pf,
  406. LAPB_RESPONSE);
  407. lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
  408. }
  409. }
  410. break;
  411. case LAPB_FRMR:
  412. lapb_dbg(1, "(%p) S3 RX FRMR(%d) %5ph\n",
  413. lapb->dev, frame->pf,
  414. skb->data);
  415. lapb_establish_data_link(lapb);
  416. lapb_dbg(0, "(%p) S3 -> S1\n", lapb->dev);
  417. lapb_requeue_frames(lapb);
  418. lapb->state = LAPB_STATE_1;
  419. break;
  420. case LAPB_ILLEGAL:
  421. lapb_dbg(1, "(%p) S3 RX ILLEGAL(%d)\n", lapb->dev, frame->pf);
  422. lapb->frmr_data = *frame;
  423. lapb->frmr_type = LAPB_FRMR_W;
  424. lapb_transmit_frmr(lapb);
  425. lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
  426. lapb_start_t1timer(lapb);
  427. lapb_stop_t2timer(lapb);
  428. lapb->state = LAPB_STATE_4;
  429. lapb->n2count = 0;
  430. break;
  431. }
  432. if (!queued)
  433. kfree_skb(skb);
  434. }
  435. /*
  436. * State machine for state 4, Frame Reject State.
  437. * The handling of the timer(s) is in file lapb_timer.c.
  438. */
  439. static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb,
  440. struct lapb_frame *frame)
  441. {
  442. switch (frame->type) {
  443. case LAPB_SABM:
  444. lapb_dbg(1, "(%p) S4 RX SABM(%d)\n", lapb->dev, frame->pf);
  445. if (lapb->mode & LAPB_EXTENDED) {
  446. lapb_dbg(1, "(%p) S4 TX DM(%d)\n",
  447. lapb->dev, frame->pf);
  448. lapb_send_control(lapb, LAPB_DM, frame->pf,
  449. LAPB_RESPONSE);
  450. } else {
  451. lapb_dbg(1, "(%p) S4 TX UA(%d)\n",
  452. lapb->dev, frame->pf);
  453. lapb_dbg(0, "(%p) S4 -> S3\n", lapb->dev);
  454. lapb_send_control(lapb, LAPB_UA, frame->pf,
  455. LAPB_RESPONSE);
  456. lapb_stop_t1timer(lapb);
  457. lapb_stop_t2timer(lapb);
  458. lapb->state = LAPB_STATE_3;
  459. lapb->condition = 0x00;
  460. lapb->n2count = 0;
  461. lapb->vs = 0;
  462. lapb->vr = 0;
  463. lapb->va = 0;
  464. lapb_connect_indication(lapb, LAPB_OK);
  465. }
  466. break;
  467. case LAPB_SABME:
  468. lapb_dbg(1, "(%p) S4 RX SABME(%d)\n", lapb->dev, frame->pf);
  469. if (lapb->mode & LAPB_EXTENDED) {
  470. lapb_dbg(1, "(%p) S4 TX UA(%d)\n",
  471. lapb->dev, frame->pf);
  472. lapb_dbg(0, "(%p) S4 -> S3\n", lapb->dev);
  473. lapb_send_control(lapb, LAPB_UA, frame->pf,
  474. LAPB_RESPONSE);
  475. lapb_stop_t1timer(lapb);
  476. lapb_stop_t2timer(lapb);
  477. lapb->state = LAPB_STATE_3;
  478. lapb->condition = 0x00;
  479. lapb->n2count = 0;
  480. lapb->vs = 0;
  481. lapb->vr = 0;
  482. lapb->va = 0;
  483. lapb_connect_indication(lapb, LAPB_OK);
  484. } else {
  485. lapb_dbg(1, "(%p) S4 TX DM(%d)\n",
  486. lapb->dev, frame->pf);
  487. lapb_send_control(lapb, LAPB_DM, frame->pf,
  488. LAPB_RESPONSE);
  489. }
  490. break;
  491. }
  492. kfree_skb(skb);
  493. }
  494. /*
  495. * Process an incoming LAPB frame
  496. */
  497. void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *skb)
  498. {
  499. struct lapb_frame frame;
  500. if (lapb_decode(lapb, skb, &frame) < 0) {
  501. kfree_skb(skb);
  502. return;
  503. }
  504. switch (lapb->state) {
  505. case LAPB_STATE_0:
  506. lapb_state0_machine(lapb, skb, &frame); break;
  507. case LAPB_STATE_1:
  508. lapb_state1_machine(lapb, skb, &frame); break;
  509. case LAPB_STATE_2:
  510. lapb_state2_machine(lapb, skb, &frame); break;
  511. case LAPB_STATE_3:
  512. lapb_state3_machine(lapb, skb, &frame); break;
  513. case LAPB_STATE_4:
  514. lapb_state4_machine(lapb, skb, &frame); break;
  515. }
  516. lapb_kick(lapb);
  517. }