CoCalc -- lapb

GitHub Repository: awilliam/linux-vfio
Path: blob/master/net/lapb/lapb_in.c
¹⁵¹¹¹ views
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 <linux/slab.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>
38

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(struct lapb_cb *lapb, struct sk_buff *skb,
44
				struct lapb_frame *frame)
45
{
46
	switch (frame->type) {
47
		case LAPB_SABM:
48
#if LAPB_DEBUG > 1
49
			printk(KERN_DEBUG "lapb: (%p) S0 RX SABM(%d)\n",
50
			       lapb->dev, frame->pf);
51
#endif
52
			if (lapb->mode & LAPB_EXTENDED) {
53
#if LAPB_DEBUG > 1
54
				printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
55
				       lapb->dev, frame->pf);
56
#endif
57
				lapb_send_control(lapb, LAPB_DM, frame->pf,
58
						  LAPB_RESPONSE);
59
			} else {
60
#if LAPB_DEBUG > 1
61
				printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
62
				       lapb->dev, frame->pf);
63
#endif
64
#if LAPB_DEBUG > 0
65
				printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n",
66
				       lapb->dev);
67
#endif
68
				lapb_send_control(lapb, LAPB_UA, frame->pf,
69
						  LAPB_RESPONSE);
70
				lapb_stop_t1timer(lapb);
71
				lapb_stop_t2timer(lapb);
72
				lapb->state     = LAPB_STATE_3;
73
				lapb->condition = 0x00;
74
				lapb->n2count   = 0;
75
				lapb->vs        = 0;
76
				lapb->vr        = 0;
77
				lapb->va        = 0;
78
				lapb_connect_indication(lapb, LAPB_OK);
79
			}
80
			break;
81

82
		case LAPB_SABME:
83
#if LAPB_DEBUG > 1
84
			printk(KERN_DEBUG "lapb: (%p) S0 RX SABME(%d)\n",
85
			       lapb->dev, frame->pf);
86
#endif
87
			if (lapb->mode & LAPB_EXTENDED) {
88
#if LAPB_DEBUG > 1
89
				printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
90
				       lapb->dev, frame->pf);
91
#endif
92
#if LAPB_DEBUG > 0
93
				printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n",
94
				       lapb->dev);
95
#endif
96
				lapb_send_control(lapb, LAPB_UA, frame->pf,
97
						  LAPB_RESPONSE);
98
				lapb_stop_t1timer(lapb);
99
				lapb_stop_t2timer(lapb);
100
				lapb->state     = LAPB_STATE_3;
101
				lapb->condition = 0x00;
102
				lapb->n2count   = 0;
103
				lapb->vs        = 0;
104
				lapb->vr        = 0;
105
				lapb->va        = 0;
106
				lapb_connect_indication(lapb, LAPB_OK);
107
			} else {
108
#if LAPB_DEBUG > 1
109
				printk(KERN_DEBUG "lapb: (%p) S0 TX DM(%d)\n",
110
				       lapb->dev, frame->pf);
111
#endif
112
				lapb_send_control(lapb, LAPB_DM, frame->pf,
113
						  LAPB_RESPONSE);
114
			}
115
			break;
116

117
		case LAPB_DISC:
118
#if LAPB_DEBUG > 1
119
			printk(KERN_DEBUG "lapb: (%p) S0 RX DISC(%d)\n",
120
			       lapb->dev, frame->pf);
121
			printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
122
			       lapb->dev, frame->pf);
123
#endif
124
			lapb_send_control(lapb, LAPB_UA, frame->pf,
125
					  LAPB_RESPONSE);
126
			break;
127

128
		default:
129
			break;
130
	}
131

132
	kfree_skb(skb);
133
}
134

135
/*
136
 *	State machine for state 1, Awaiting Connection State.
137
 *	The handling of the timer(s) is in file lapb_timer.c.
138
 */
139
static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb,
140
				struct lapb_frame *frame)
141
{
142
	switch (frame->type) {
143
		case LAPB_SABM:
144
#if LAPB_DEBUG > 1
145
			printk(KERN_DEBUG "lapb: (%p) S1 RX SABM(%d)\n",
146
			       lapb->dev, frame->pf);
147
#endif
148
			if (lapb->mode & LAPB_EXTENDED) {
149
#if LAPB_DEBUG > 1
150
				printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
151
				       lapb->dev, frame->pf);
152
#endif
153
				lapb_send_control(lapb, LAPB_DM, frame->pf,
154
						  LAPB_RESPONSE);
155
			} else {
156
#if LAPB_DEBUG > 1
157
				printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
158
				       lapb->dev, frame->pf);
159
#endif
160
				lapb_send_control(lapb, LAPB_UA, frame->pf,
161
						  LAPB_RESPONSE);
162
			}
163
			break;
164

165
		case LAPB_SABME:
166
#if LAPB_DEBUG > 1
167
			printk(KERN_DEBUG "lapb: (%p) S1 RX SABME(%d)\n",
168
			       lapb->dev, frame->pf);
169
#endif
170
			if (lapb->mode & LAPB_EXTENDED) {
171
#if LAPB_DEBUG > 1
172
				printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
173
				       lapb->dev, frame->pf);
174
#endif
175
				lapb_send_control(lapb, LAPB_UA, frame->pf,
176
						  LAPB_RESPONSE);
177
			} else {
178
#if LAPB_DEBUG > 1
179
				printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
180
				       lapb->dev, frame->pf);
181
#endif
182
				lapb_send_control(lapb, LAPB_DM, frame->pf,
183
						  LAPB_RESPONSE);
184
			}
185
			break;
186

187
		case LAPB_DISC:
188
#if LAPB_DEBUG > 1
189
			printk(KERN_DEBUG "lapb: (%p) S1 RX DISC(%d)\n",
190
			       lapb->dev, frame->pf);
191
			printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
192
			       lapb->dev, frame->pf);
193
#endif
194
			lapb_send_control(lapb, LAPB_DM, frame->pf,
195
					  LAPB_RESPONSE);
196
			break;
197

198
		case LAPB_UA:
199
#if LAPB_DEBUG > 1
200
			printk(KERN_DEBUG "lapb: (%p) S1 RX UA(%d)\n",
201
			       lapb->dev, frame->pf);
202
#endif
203
			if (frame->pf) {
204
#if LAPB_DEBUG > 0
205
				printk(KERN_DEBUG "lapb: (%p) S1 -> S3\n",
206
				       lapb->dev);
207
#endif
208
				lapb_stop_t1timer(lapb);
209
				lapb_stop_t2timer(lapb);
210
				lapb->state     = LAPB_STATE_3;
211
				lapb->condition = 0x00;
212
				lapb->n2count   = 0;
213
				lapb->vs        = 0;
214
				lapb->vr        = 0;
215
				lapb->va        = 0;
216
				lapb_connect_confirmation(lapb, LAPB_OK);
217
			}
218
			break;
219

220
		case LAPB_DM:
221
#if LAPB_DEBUG > 1
222
			printk(KERN_DEBUG "lapb: (%p) S1 RX DM(%d)\n",
223
			       lapb->dev, frame->pf);
224
#endif
225
			if (frame->pf) {
226
#if LAPB_DEBUG > 0
227
				printk(KERN_DEBUG "lapb: (%p) S1 -> S0\n",
228
				       lapb->dev);
229
#endif
230
				lapb_clear_queues(lapb);
231
				lapb->state = LAPB_STATE_0;
232
				lapb_start_t1timer(lapb);
233
				lapb_stop_t2timer(lapb);
234
				lapb_disconnect_indication(lapb, LAPB_REFUSED);
235
			}
236
			break;
237
	}
238

239
	kfree_skb(skb);
240
}
241

242
/*
243
 *	State machine for state 2, Awaiting Release State.
244
 *	The handling of the timer(s) is in file lapb_timer.c
245
 */
246
static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb,
247
				struct lapb_frame *frame)
248
{
249
	switch (frame->type) {
250
		case LAPB_SABM:
251
		case LAPB_SABME:
252
#if LAPB_DEBUG > 1
253
			printk(KERN_DEBUG "lapb: (%p) S2 RX {SABM,SABME}(%d)\n",
254
			       lapb->dev, frame->pf);
255
			printk(KERN_DEBUG "lapb: (%p) S2 TX DM(%d)\n",
256
			       lapb->dev, frame->pf);
257
#endif
258
			lapb_send_control(lapb, LAPB_DM, frame->pf,
259
					  LAPB_RESPONSE);
260
			break;
261

262
		case LAPB_DISC:
263
#if LAPB_DEBUG > 1
264
			printk(KERN_DEBUG "lapb: (%p) S2 RX DISC(%d)\n",
265
			       lapb->dev, frame->pf);
266
			printk(KERN_DEBUG "lapb: (%p) S2 TX UA(%d)\n",
267
			       lapb->dev, frame->pf);
268
#endif
269
			lapb_send_control(lapb, LAPB_UA, frame->pf,
270
					  LAPB_RESPONSE);
271
			break;
272

273
		case LAPB_UA:
274
#if LAPB_DEBUG > 1
275
			printk(KERN_DEBUG "lapb: (%p) S2 RX UA(%d)\n",
276
			       lapb->dev, frame->pf);
277
#endif
278
			if (frame->pf) {
279
#if LAPB_DEBUG > 0
280
				printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n",
281
				       lapb->dev);
282
#endif
283
				lapb->state = LAPB_STATE_0;
284
				lapb_start_t1timer(lapb);
285
				lapb_stop_t2timer(lapb);
286
				lapb_disconnect_confirmation(lapb, LAPB_OK);
287
			}
288
			break;
289

290
		case LAPB_DM:
291
#if LAPB_DEBUG > 1
292
			printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
293
			       lapb->dev, frame->pf);
294
#endif
295
			if (frame->pf) {
296
#if LAPB_DEBUG > 0
297
				printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n",
298
				       lapb->dev);
299
#endif
300
				lapb->state = LAPB_STATE_0;
301
				lapb_start_t1timer(lapb);
302
				lapb_stop_t2timer(lapb);
303
				lapb_disconnect_confirmation(lapb,
304
							     LAPB_NOTCONNECTED);
305
			}
306
			break;
307

308
		case LAPB_I:
309
		case LAPB_REJ:
310
		case LAPB_RNR:
311
		case LAPB_RR:
312
#if LAPB_DEBUG > 1
313
			printk(KERN_DEBUG "lapb: (%p) S2 RX {I,REJ,RNR,RR}"
314
			       "(%d)\n", lapb->dev, frame->pf);
315
			printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
316
			       lapb->dev, frame->pf);
317
#endif
318
			if (frame->pf)
319
				lapb_send_control(lapb, LAPB_DM, frame->pf,
320
						  LAPB_RESPONSE);
321
			break;
322
	}
323

324
	kfree_skb(skb);
325
}
326

327
/*
328
 *	State machine for state 3, Connected State.
329
 *	The handling of the timer(s) is in file lapb_timer.c
330
 */
331
static void lapb_state3_machine(struct lapb_cb *lapb, struct sk_buff *skb,
332
				struct lapb_frame *frame)
333
{
334
	int queued = 0;
335
	int modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS :
336
						     LAPB_SMODULUS;
337

338
	switch (frame->type) {
339
		case LAPB_SABM:
340
#if LAPB_DEBUG > 1
341
			printk(KERN_DEBUG "lapb: (%p) S3 RX SABM(%d)\n",
342
			       lapb->dev, frame->pf);
343
#endif
344
			if (lapb->mode & LAPB_EXTENDED) {
345
#if LAPB_DEBUG > 1
346
				printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
347
				       lapb->dev, frame->pf);
348
#endif
349
				lapb_send_control(lapb, LAPB_DM, frame->pf,
350
						  LAPB_RESPONSE);
351
			} else {
352
#if LAPB_DEBUG > 1
353
				printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
354
				       lapb->dev, frame->pf);
355
#endif
356
				lapb_send_control(lapb, LAPB_UA, frame->pf,
357
						  LAPB_RESPONSE);
358
				lapb_stop_t1timer(lapb);
359
				lapb_stop_t2timer(lapb);
360
				lapb->condition = 0x00;
361
				lapb->n2count   = 0;
362
				lapb->vs        = 0;
363
				lapb->vr        = 0;
364
				lapb->va        = 0;
365
				lapb_requeue_frames(lapb);
366
			}
367
			break;
368

369
		case LAPB_SABME:
370
#if LAPB_DEBUG > 1
371
			printk(KERN_DEBUG "lapb: (%p) S3 RX SABME(%d)\n",
372
			       lapb->dev, frame->pf);
373
#endif
374
			if (lapb->mode & LAPB_EXTENDED) {
375
#if LAPB_DEBUG > 1
376
				printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
377
				       lapb->dev, frame->pf);
378
#endif
379
				lapb_send_control(lapb, LAPB_UA, frame->pf,
380
						  LAPB_RESPONSE);
381
				lapb_stop_t1timer(lapb);
382
				lapb_stop_t2timer(lapb);
383
				lapb->condition = 0x00;
384
				lapb->n2count   = 0;
385
				lapb->vs        = 0;
386
				lapb->vr        = 0;
387
				lapb->va        = 0;
388
				lapb_requeue_frames(lapb);
389
			} else {
390
#if LAPB_DEBUG > 1
391
				printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
392
				       lapb->dev, frame->pf);
393
#endif
394
				lapb_send_control(lapb, LAPB_DM, frame->pf,
395
						  LAPB_RESPONSE);
396
			}
397
			break;
398

399
		case LAPB_DISC:
400
#if LAPB_DEBUG > 1
401
			printk(KERN_DEBUG "lapb: (%p) S3 RX DISC(%d)\n",
402
			       lapb->dev, frame->pf);
403
#endif
404
#if LAPB_DEBUG > 0
405
			printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n",
406
			       lapb->dev);
407
#endif
408
			lapb_clear_queues(lapb);
409
			lapb_send_control(lapb, LAPB_UA, frame->pf,
410
					  LAPB_RESPONSE);
411
			lapb_start_t1timer(lapb);
412
			lapb_stop_t2timer(lapb);
413
			lapb->state = LAPB_STATE_0;
414
			lapb_disconnect_indication(lapb, LAPB_OK);
415
			break;
416

417
		case LAPB_DM:
418
#if LAPB_DEBUG > 1
419
			printk(KERN_DEBUG "lapb: (%p) S3 RX DM(%d)\n",
420
			       lapb->dev, frame->pf);
421
#endif
422
#if LAPB_DEBUG > 0
423
			printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n",
424
			       lapb->dev);
425
#endif
426
			lapb_clear_queues(lapb);
427
			lapb->state = LAPB_STATE_0;
428
			lapb_start_t1timer(lapb);
429
			lapb_stop_t2timer(lapb);
430
			lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED);
431
			break;
432

433
		case LAPB_RNR:
434
#if LAPB_DEBUG > 1
435
			printk(KERN_DEBUG "lapb: (%p) S3 RX RNR(%d) R%d\n",
436
			       lapb->dev, frame->pf, frame->nr);
437
#endif
438
			lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION;
439
			lapb_check_need_response(lapb, frame->cr, frame->pf);
440
			if (lapb_validate_nr(lapb, frame->nr)) {
441
				lapb_check_iframes_acked(lapb, frame->nr);
442
			} else {
443
				lapb->frmr_data = *frame;
444
				lapb->frmr_type = LAPB_FRMR_Z;
445
				lapb_transmit_frmr(lapb);
446
#if LAPB_DEBUG > 0
447
				printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
448
				       lapb->dev);
449
#endif
450
				lapb_start_t1timer(lapb);
451
				lapb_stop_t2timer(lapb);
452
				lapb->state   = LAPB_STATE_4;
453
				lapb->n2count = 0;
454
			}
455
			break;
456

457
		case LAPB_RR:
458
#if LAPB_DEBUG > 1
459
			printk(KERN_DEBUG "lapb: (%p) S3 RX RR(%d) R%d\n",
460
			       lapb->dev, frame->pf, frame->nr);
461
#endif
462
			lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
463
			lapb_check_need_response(lapb, frame->cr, frame->pf);
464
			if (lapb_validate_nr(lapb, frame->nr)) {
465
				lapb_check_iframes_acked(lapb, frame->nr);
466
			} else {
467
				lapb->frmr_data = *frame;
468
				lapb->frmr_type = LAPB_FRMR_Z;
469
				lapb_transmit_frmr(lapb);
470
#if LAPB_DEBUG > 0
471
				printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
472
				       lapb->dev);
473
#endif
474
				lapb_start_t1timer(lapb);
475
				lapb_stop_t2timer(lapb);
476
				lapb->state   = LAPB_STATE_4;
477
				lapb->n2count = 0;
478
			}
479
			break;
480

481
		case LAPB_REJ:
482
#if LAPB_DEBUG > 1
483
			printk(KERN_DEBUG "lapb: (%p) S3 RX REJ(%d) R%d\n",
484
			       lapb->dev, frame->pf, frame->nr);
485
#endif
486
			lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
487
			lapb_check_need_response(lapb, frame->cr, frame->pf);
488
			if (lapb_validate_nr(lapb, frame->nr)) {
489
				lapb_frames_acked(lapb, frame->nr);
490
				lapb_stop_t1timer(lapb);
491
				lapb->n2count = 0;
492
				lapb_requeue_frames(lapb);
493
			} else {
494
				lapb->frmr_data = *frame;
495
				lapb->frmr_type = LAPB_FRMR_Z;
496
				lapb_transmit_frmr(lapb);
497
#if LAPB_DEBUG > 0
498
				printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
499
				       lapb->dev);
500
#endif
501
				lapb_start_t1timer(lapb);
502
				lapb_stop_t2timer(lapb);
503
				lapb->state   = LAPB_STATE_4;
504
				lapb->n2count = 0;
505
			}
506
			break;
507

508
		case LAPB_I:
509
#if LAPB_DEBUG > 1
510
			printk(KERN_DEBUG "lapb: (%p) S3 RX I(%d) S%d R%d\n",
511
			       lapb->dev, frame->pf, frame->ns, frame->nr);
512
#endif
513
			if (!lapb_validate_nr(lapb, frame->nr)) {
514
				lapb->frmr_data = *frame;
515
				lapb->frmr_type = LAPB_FRMR_Z;
516
				lapb_transmit_frmr(lapb);
517
#if LAPB_DEBUG > 0
518
				printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n",
519
				       lapb->dev);
520
#endif
521
				lapb_start_t1timer(lapb);
522
				lapb_stop_t2timer(lapb);
523
				lapb->state   = LAPB_STATE_4;
524
				lapb->n2count = 0;
525
				break;
526
			}
527
			if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION)
528
				lapb_frames_acked(lapb, frame->nr);
529
			else
530
				lapb_check_iframes_acked(lapb, frame->nr);
531

532
			if (frame->ns == lapb->vr) {
533
				int cn;
534
				cn = lapb_data_indication(lapb, skb);
535
				queued = 1;
536
				/*
537
				 * If upper layer has dropped the frame, we
538
				 * basically ignore any further protocol
539
				 * processing. This will cause the peer
540
				 * to re-transmit the frame later like
541
				 * a frame lost on the wire.
542
				 */
543
				if (cn == NET_RX_DROP) {
544
					printk(KERN_DEBUG
545
					       "LAPB: rx congestion\n");
546
					break;
547
				}
548
				lapb->vr = (lapb->vr + 1) % modulus;
549
				lapb->condition &= ~LAPB_REJECT_CONDITION;
550
				if (frame->pf)
551
					lapb_enquiry_response(lapb);
552
				else {
553
					if (!(lapb->condition &
554
					      LAPB_ACK_PENDING_CONDITION)) {
555
						lapb->condition |= LAPB_ACK_PENDING_CONDITION;
556
						lapb_start_t2timer(lapb);
557
					}
558
				}
559
			} else {
560
				if (lapb->condition & LAPB_REJECT_CONDITION) {
561
					if (frame->pf)
562
						lapb_enquiry_response(lapb);
563
				} else {
564
#if LAPB_DEBUG > 1
565
					printk(KERN_DEBUG
566
					       "lapb: (%p) S3 TX REJ(%d) R%d\n",
567
					       lapb->dev, frame->pf, lapb->vr);
568
#endif
569
					lapb->condition |= LAPB_REJECT_CONDITION;
570
					lapb_send_control(lapb, LAPB_REJ,
571
							  frame->pf,
572
							  LAPB_RESPONSE);
573
					lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
574
				}
575
			}
576
			break;
577

578
		case LAPB_FRMR:
579
#if LAPB_DEBUG > 1
580
			printk(KERN_DEBUG "lapb: (%p) S3 RX FRMR(%d) %02X "
581
			       "%02X %02X %02X %02X\n", lapb->dev, frame->pf,
582
			       skb->data[0], skb->data[1], skb->data[2],
583
			       skb->data[3], skb->data[4]);
584
#endif
585
			lapb_establish_data_link(lapb);
586
#if LAPB_DEBUG > 0
587
			printk(KERN_DEBUG "lapb: (%p) S3 -> S1\n",
588
			       lapb->dev);
589
#endif
590
			lapb_requeue_frames(lapb);
591
			lapb->state = LAPB_STATE_1;
592
			break;
593

594
		case LAPB_ILLEGAL:
595
#if LAPB_DEBUG > 1
596
			printk(KERN_DEBUG "lapb: (%p) S3 RX ILLEGAL(%d)\n",
597
			       lapb->dev, frame->pf);
598
#endif
599
			lapb->frmr_data = *frame;
600
			lapb->frmr_type = LAPB_FRMR_W;
601
			lapb_transmit_frmr(lapb);
602
#if LAPB_DEBUG > 0
603
			printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
604
#endif
605
			lapb_start_t1timer(lapb);
606
			lapb_stop_t2timer(lapb);
607
			lapb->state   = LAPB_STATE_4;
608
			lapb->n2count = 0;
609
			break;
610
	}
611

612
	if (!queued)
613
		kfree_skb(skb);
614
}
615

616
/*
617
 *	State machine for state 4, Frame Reject State.
618
 *	The handling of the timer(s) is in file lapb_timer.c.
619
 */
620
static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb,
621
				struct lapb_frame *frame)
622
{
623
	switch (frame->type) {
624
		case LAPB_SABM:
625
#if LAPB_DEBUG > 1
626
			printk(KERN_DEBUG "lapb: (%p) S4 RX SABM(%d)\n",
627
			       lapb->dev, frame->pf);
628
#endif
629
			if (lapb->mode & LAPB_EXTENDED) {
630
#if LAPB_DEBUG > 1
631
				printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
632
				       lapb->dev, frame->pf);
633
#endif
634
				lapb_send_control(lapb, LAPB_DM, frame->pf,
635
						  LAPB_RESPONSE);
636
			} else {
637
#if LAPB_DEBUG > 1
638
				printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
639
				       lapb->dev, frame->pf);
640
#endif
641
#if LAPB_DEBUG > 0
642
				printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n",
643
				       lapb->dev);
644
#endif
645
				lapb_send_control(lapb, LAPB_UA, frame->pf,
646
						  LAPB_RESPONSE);
647
				lapb_stop_t1timer(lapb);
648
				lapb_stop_t2timer(lapb);
649
				lapb->state     = LAPB_STATE_3;
650
				lapb->condition = 0x00;
651
				lapb->n2count   = 0;
652
				lapb->vs        = 0;
653
				lapb->vr        = 0;
654
				lapb->va        = 0;
655
				lapb_connect_indication(lapb, LAPB_OK);
656
			}
657
			break;
658

659
		case LAPB_SABME:
660
#if LAPB_DEBUG > 1
661
			printk(KERN_DEBUG "lapb: (%p) S4 RX SABME(%d)\n",
662
			       lapb->dev, frame->pf);
663
#endif
664
			if (lapb->mode & LAPB_EXTENDED) {
665
#if LAPB_DEBUG > 1
666
				printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
667
				       lapb->dev, frame->pf);
668
#endif
669
#if LAPB_DEBUG > 0
670
				printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n",
671
				       lapb->dev);
672
#endif
673
				lapb_send_control(lapb, LAPB_UA, frame->pf,
674
						  LAPB_RESPONSE);
675
				lapb_stop_t1timer(lapb);
676
				lapb_stop_t2timer(lapb);
677
				lapb->state     = LAPB_STATE_3;
678
				lapb->condition = 0x00;
679
				lapb->n2count   = 0;
680
				lapb->vs        = 0;
681
				lapb->vr        = 0;
682
				lapb->va        = 0;
683
				lapb_connect_indication(lapb, LAPB_OK);
684
			} else {
685
#if LAPB_DEBUG > 1
686
				printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
687
				       lapb->dev, frame->pf);
688
#endif
689
				lapb_send_control(lapb, LAPB_DM, frame->pf,
690
						  LAPB_RESPONSE);
691
			}
692
			break;
693
	}
694

695
	kfree_skb(skb);
696
}
697

698
/*
699
 *	Process an incoming LAPB frame
700
 */
701
void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *skb)
702
{
703
	struct lapb_frame frame;
704

705
	if (lapb_decode(lapb, skb, &frame) < 0) {
706
		kfree_skb(skb);
707
		return;
708
	}
709

710
	switch (lapb->state) {
711
	case LAPB_STATE_0:
712
		lapb_state0_machine(lapb, skb, &frame); break;
713
	case LAPB_STATE_1:
714
		lapb_state1_machine(lapb, skb, &frame); break;
715
	case LAPB_STATE_2:
716
		lapb_state2_machine(lapb, skb, &frame); break;
717
	case LAPB_STATE_3:
718
		lapb_state3_machine(lapb, skb, &frame); break;
719
	case LAPB_STATE_4:
720
		lapb_state4_machine(lapb, skb, &frame); break;
721
	}
722

723
	lapb_kick(lapb);
724
}
725

726
Product

Resources

Company
