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