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