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