开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
lapb_in.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：17k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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