CoCalc -- lapb

GitHub Repository: torvalds/linux
Path: blob/master/net/lapb/lapb_in.c
²⁶¹⁴⁶ views
1
// SPDX-License-Identifier: GPL-2.0-or-later
2
/*
3
 *	LAPB release 002
4
 *
5
 *	This code REQUIRES 2.1.15 or higher/ NET3.038
6
 *
7
 *	History
8
 *	LAPB 001	Jonathan Naulor	Started Coding
9
 *	LAPB 002	Jonathan Naylor	New timer architecture.
10
 *	2000-10-29	Henner Eisen	lapb_data_indication() return status.
11
 */
12

13
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14

15
#include <linux/errno.h>
16
#include <linux/types.h>
17
#include <linux/socket.h>
18
#include <linux/in.h>
19
#include <linux/kernel.h>
20
#include <linux/timer.h>
21
#include <linux/string.h>
22
#include <linux/sockios.h>
23
#include <linux/net.h>
24
#include <linux/inet.h>
25
#include <linux/netdevice.h>
26
#include <linux/skbuff.h>
27
#include <linux/slab.h>
28
#include <net/sock.h>
29
#include <linux/uaccess.h>
30
#include <linux/fcntl.h>
31
#include <linux/mm.h>
32
#include <linux/interrupt.h>
33
#include <net/lapb.h>
34

35
/*
36
 *	State machine for state 0, Disconnected State.
37
 *	The handling of the timer(s) is in file lapb_timer.c.
38
 */
39
static void lapb_state0_machine(struct lapb_cb *lapb, struct sk_buff *skb,
40
				struct lapb_frame *frame)
41
{
42
	switch (frame->type) {
43
	case LAPB_SABM:
44
		lapb_dbg(1, "(%p) S0 RX SABM(%d)\n", lapb->dev, frame->pf);
45
		if (lapb->mode & LAPB_EXTENDED) {
46
			lapb_dbg(1, "(%p) S0 TX DM(%d)\n",
47
				 lapb->dev, frame->pf);
48
			lapb_send_control(lapb, LAPB_DM, frame->pf,
49
					  LAPB_RESPONSE);
50
		} else {
51
			lapb_dbg(1, "(%p) S0 TX UA(%d)\n",
52
				 lapb->dev, frame->pf);
53
			lapb_dbg(0, "(%p) S0 -> S3\n", lapb->dev);
54
			lapb_send_control(lapb, LAPB_UA, frame->pf,
55
					  LAPB_RESPONSE);
56
			lapb_stop_t1timer(lapb);
57
			lapb_stop_t2timer(lapb);
58
			lapb->state     = LAPB_STATE_3;
59
			lapb->condition = 0x00;
60
			lapb->n2count   = 0;
61
			lapb->vs        = 0;
62
			lapb->vr        = 0;
63
			lapb->va        = 0;
64
			lapb_connect_indication(lapb, LAPB_OK);
65
		}
66
		break;
67

68
	case LAPB_SABME:
69
		lapb_dbg(1, "(%p) S0 RX SABME(%d)\n", lapb->dev, frame->pf);
70
		if (lapb->mode & LAPB_EXTENDED) {
71
			lapb_dbg(1, "(%p) S0 TX UA(%d)\n",
72
				 lapb->dev, frame->pf);
73
			lapb_dbg(0, "(%p) S0 -> S3\n", lapb->dev);
74
			lapb_send_control(lapb, LAPB_UA, frame->pf,
75
					  LAPB_RESPONSE);
76
			lapb_stop_t1timer(lapb);
77
			lapb_stop_t2timer(lapb);
78
			lapb->state     = LAPB_STATE_3;
79
			lapb->condition = 0x00;
80
			lapb->n2count   = 0;
81
			lapb->vs        = 0;
82
			lapb->vr        = 0;
83
			lapb->va        = 0;
84
			lapb_connect_indication(lapb, LAPB_OK);
85
		} else {
86
			lapb_dbg(1, "(%p) S0 TX DM(%d)\n",
87
				 lapb->dev, frame->pf);
88
			lapb_send_control(lapb, LAPB_DM, frame->pf,
89
					  LAPB_RESPONSE);
90
		}
91
		break;
92

93
	case LAPB_DISC:
94
		lapb_dbg(1, "(%p) S0 RX DISC(%d)\n", lapb->dev, frame->pf);
95
		lapb_dbg(1, "(%p) S0 TX UA(%d)\n", lapb->dev, frame->pf);
96
		lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
97
		break;
98

99
	default:
100
		break;
101
	}
102

103
	kfree_skb(skb);
104
}
105

106
/*
107
 *	State machine for state 1, Awaiting Connection State.
108
 *	The handling of the timer(s) is in file lapb_timer.c.
109
 */
110
static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb,
111
				struct lapb_frame *frame)
112
{
113
	switch (frame->type) {
114
	case LAPB_SABM:
115
		lapb_dbg(1, "(%p) S1 RX SABM(%d)\n", lapb->dev, frame->pf);
116
		if (lapb->mode & LAPB_EXTENDED) {
117
			lapb_dbg(1, "(%p) S1 TX DM(%d)\n",
118
				 lapb->dev, frame->pf);
119
			lapb_send_control(lapb, LAPB_DM, frame->pf,
120
					  LAPB_RESPONSE);
121
		} else {
122
			lapb_dbg(1, "(%p) S1 TX UA(%d)\n",
123
				 lapb->dev, frame->pf);
124
			lapb_send_control(lapb, LAPB_UA, frame->pf,
125
					  LAPB_RESPONSE);
126
		}
127
		break;
128

129
	case LAPB_SABME:
130
		lapb_dbg(1, "(%p) S1 RX SABME(%d)\n", lapb->dev, frame->pf);
131
		if (lapb->mode & LAPB_EXTENDED) {
132
			lapb_dbg(1, "(%p) S1 TX UA(%d)\n",
133
				 lapb->dev, frame->pf);
134
			lapb_send_control(lapb, LAPB_UA, frame->pf,
135
					  LAPB_RESPONSE);
136
		} else {
137
			lapb_dbg(1, "(%p) S1 TX DM(%d)\n",
138
				 lapb->dev, frame->pf);
139
			lapb_send_control(lapb, LAPB_DM, frame->pf,
140
					  LAPB_RESPONSE);
141
		}
142
		break;
143

144
	case LAPB_DISC:
145
		lapb_dbg(1, "(%p) S1 RX DISC(%d)\n", lapb->dev, frame->pf);
146
		lapb_dbg(1, "(%p) S1 TX DM(%d)\n", lapb->dev, frame->pf);
147
		lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
148
		break;
149

150
	case LAPB_UA:
151
		lapb_dbg(1, "(%p) S1 RX UA(%d)\n", lapb->dev, frame->pf);
152
		if (frame->pf) {
153
			lapb_dbg(0, "(%p) S1 -> S3\n", lapb->dev);
154
			lapb_stop_t1timer(lapb);
155
			lapb_stop_t2timer(lapb);
156
			lapb->state     = LAPB_STATE_3;
157
			lapb->condition = 0x00;
158
			lapb->n2count   = 0;
159
			lapb->vs        = 0;
160
			lapb->vr        = 0;
161
			lapb->va        = 0;
162
			lapb_connect_confirmation(lapb, LAPB_OK);
163
		}
164
		break;
165

166
	case LAPB_DM:
167
		lapb_dbg(1, "(%p) S1 RX DM(%d)\n", lapb->dev, frame->pf);
168
		if (frame->pf) {
169
			lapb_dbg(0, "(%p) S1 -> S0\n", lapb->dev);
170
			lapb_clear_queues(lapb);
171
			lapb->state = LAPB_STATE_0;
172
			lapb_start_t1timer(lapb);
173
			lapb_stop_t2timer(lapb);
174
			lapb_disconnect_indication(lapb, LAPB_REFUSED);
175
		}
176
		break;
177
	}
178

179
	kfree_skb(skb);
180
}
181

182
/*
183
 *	State machine for state 2, Awaiting Release State.
184
 *	The handling of the timer(s) is in file lapb_timer.c
185
 */
186
static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb,
187
				struct lapb_frame *frame)
188
{
189
	switch (frame->type) {
190
	case LAPB_SABM:
191
	case LAPB_SABME:
192
		lapb_dbg(1, "(%p) S2 RX {SABM,SABME}(%d)\n",
193
			 lapb->dev, frame->pf);
194
		lapb_dbg(1, "(%p) S2 TX DM(%d)\n", lapb->dev, frame->pf);
195
		lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
196
		break;
197

198
	case LAPB_DISC:
199
		lapb_dbg(1, "(%p) S2 RX DISC(%d)\n", lapb->dev, frame->pf);
200
		lapb_dbg(1, "(%p) S2 TX UA(%d)\n", lapb->dev, frame->pf);
201
		lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
202
		break;
203

204
	case LAPB_UA:
205
		lapb_dbg(1, "(%p) S2 RX UA(%d)\n", lapb->dev, frame->pf);
206
		if (frame->pf) {
207
			lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev);
208
			lapb->state = LAPB_STATE_0;
209
			lapb_start_t1timer(lapb);
210
			lapb_stop_t2timer(lapb);
211
			lapb_disconnect_confirmation(lapb, LAPB_OK);
212
		}
213
		break;
214

215
	case LAPB_DM:
216
		lapb_dbg(1, "(%p) S2 RX DM(%d)\n", lapb->dev, frame->pf);
217
		if (frame->pf) {
218
			lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev);
219
			lapb->state = LAPB_STATE_0;
220
			lapb_start_t1timer(lapb);
221
			lapb_stop_t2timer(lapb);
222
			lapb_disconnect_confirmation(lapb, LAPB_NOTCONNECTED);
223
		}
224
		break;
225

226
	case LAPB_I:
227
	case LAPB_REJ:
228
	case LAPB_RNR:
229
	case LAPB_RR:
230
		lapb_dbg(1, "(%p) S2 RX {I,REJ,RNR,RR}(%d)\n",
231
		       lapb->dev, frame->pf);
232
		lapb_dbg(1, "(%p) S2 RX DM(%d)\n", lapb->dev, frame->pf);
233
		if (frame->pf)
234
			lapb_send_control(lapb, LAPB_DM, frame->pf,
235
					  LAPB_RESPONSE);
236
		break;
237
	}
238

239
	kfree_skb(skb);
240
}
241

242
/*
243
 *	State machine for state 3, Connected State.
244
 *	The handling of the timer(s) is in file lapb_timer.c
245
 */
246
static void lapb_state3_machine(struct lapb_cb *lapb, struct sk_buff *skb,
247
				struct lapb_frame *frame)
248
{
249
	int queued = 0;
250
	int modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS :
251
						     LAPB_SMODULUS;
252

253
	switch (frame->type) {
254
	case LAPB_SABM:
255
		lapb_dbg(1, "(%p) S3 RX SABM(%d)\n", lapb->dev, frame->pf);
256
		if (lapb->mode & LAPB_EXTENDED) {
257
			lapb_dbg(1, "(%p) S3 TX DM(%d)\n",
258
				 lapb->dev, frame->pf);
259
			lapb_send_control(lapb, LAPB_DM, frame->pf,
260
					  LAPB_RESPONSE);
261
		} else {
262
			lapb_dbg(1, "(%p) S3 TX UA(%d)\n",
263
				 lapb->dev, frame->pf);
264
			lapb_send_control(lapb, LAPB_UA, frame->pf,
265
					  LAPB_RESPONSE);
266
			lapb_stop_t1timer(lapb);
267
			lapb_stop_t2timer(lapb);
268
			lapb->condition = 0x00;
269
			lapb->n2count   = 0;
270
			lapb->vs        = 0;
271
			lapb->vr        = 0;
272
			lapb->va        = 0;
273
			lapb_requeue_frames(lapb);
274
		}
275
		break;
276

277
	case LAPB_SABME:
278
		lapb_dbg(1, "(%p) S3 RX SABME(%d)\n", lapb->dev, frame->pf);
279
		if (lapb->mode & LAPB_EXTENDED) {
280
			lapb_dbg(1, "(%p) S3 TX UA(%d)\n",
281
				 lapb->dev, frame->pf);
282
			lapb_send_control(lapb, LAPB_UA, frame->pf,
283
					  LAPB_RESPONSE);
284
			lapb_stop_t1timer(lapb);
285
			lapb_stop_t2timer(lapb);
286
			lapb->condition = 0x00;
287
			lapb->n2count   = 0;
288
			lapb->vs        = 0;
289
			lapb->vr        = 0;
290
			lapb->va        = 0;
291
			lapb_requeue_frames(lapb);
292
		} else {
293
			lapb_dbg(1, "(%p) S3 TX DM(%d)\n",
294
				 lapb->dev, frame->pf);
295
			lapb_send_control(lapb, LAPB_DM, frame->pf,
296
					  LAPB_RESPONSE);
297
		}
298
		break;
299

300
	case LAPB_DISC:
301
		lapb_dbg(1, "(%p) S3 RX DISC(%d)\n", lapb->dev, frame->pf);
302
		lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev);
303
		lapb_clear_queues(lapb);
304
		lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
305
		lapb_start_t1timer(lapb);
306
		lapb_stop_t2timer(lapb);
307
		lapb->state = LAPB_STATE_0;
308
		lapb_disconnect_indication(lapb, LAPB_OK);
309
		break;
310

311
	case LAPB_DM:
312
		lapb_dbg(1, "(%p) S3 RX DM(%d)\n", lapb->dev, frame->pf);
313
		lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev);
314
		lapb_clear_queues(lapb);
315
		lapb->state = LAPB_STATE_0;
316
		lapb_start_t1timer(lapb);
317
		lapb_stop_t2timer(lapb);
318
		lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED);
319
		break;
320

321
	case LAPB_RNR:
322
		lapb_dbg(1, "(%p) S3 RX RNR(%d) R%d\n",
323
			 lapb->dev, frame->pf, frame->nr);
324
		lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION;
325
		lapb_check_need_response(lapb, frame->cr, frame->pf);
326
		if (lapb_validate_nr(lapb, frame->nr)) {
327
			lapb_check_iframes_acked(lapb, frame->nr);
328
		} else {
329
			lapb->frmr_data = *frame;
330
			lapb->frmr_type = LAPB_FRMR_Z;
331
			lapb_transmit_frmr(lapb);
332
			lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
333
			lapb_start_t1timer(lapb);
334
			lapb_stop_t2timer(lapb);
335
			lapb->state   = LAPB_STATE_4;
336
			lapb->n2count = 0;
337
		}
338
		break;
339

340
	case LAPB_RR:
341
		lapb_dbg(1, "(%p) S3 RX RR(%d) R%d\n",
342
			 lapb->dev, frame->pf, frame->nr);
343
		lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
344
		lapb_check_need_response(lapb, frame->cr, frame->pf);
345
		if (lapb_validate_nr(lapb, frame->nr)) {
346
			lapb_check_iframes_acked(lapb, frame->nr);
347
		} else {
348
			lapb->frmr_data = *frame;
349
			lapb->frmr_type = LAPB_FRMR_Z;
350
			lapb_transmit_frmr(lapb);
351
			lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
352
			lapb_start_t1timer(lapb);
353
			lapb_stop_t2timer(lapb);
354
			lapb->state   = LAPB_STATE_4;
355
			lapb->n2count = 0;
356
		}
357
		break;
358

359
	case LAPB_REJ:
360
		lapb_dbg(1, "(%p) S3 RX REJ(%d) R%d\n",
361
			 lapb->dev, frame->pf, frame->nr);
362
		lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
363
		lapb_check_need_response(lapb, frame->cr, frame->pf);
364
		if (lapb_validate_nr(lapb, frame->nr)) {
365
			lapb_frames_acked(lapb, frame->nr);
366
			lapb_stop_t1timer(lapb);
367
			lapb->n2count = 0;
368
			lapb_requeue_frames(lapb);
369
		} else {
370
			lapb->frmr_data = *frame;
371
			lapb->frmr_type = LAPB_FRMR_Z;
372
			lapb_transmit_frmr(lapb);
373
			lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
374
			lapb_start_t1timer(lapb);
375
			lapb_stop_t2timer(lapb);
376
			lapb->state   = LAPB_STATE_4;
377
			lapb->n2count = 0;
378
		}
379
		break;
380

381
	case LAPB_I:
382
		lapb_dbg(1, "(%p) S3 RX I(%d) S%d R%d\n",
383
			 lapb->dev, frame->pf, frame->ns, frame->nr);
384
		if (!lapb_validate_nr(lapb, frame->nr)) {
385
			lapb->frmr_data = *frame;
386
			lapb->frmr_type = LAPB_FRMR_Z;
387
			lapb_transmit_frmr(lapb);
388
			lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
389
			lapb_start_t1timer(lapb);
390
			lapb_stop_t2timer(lapb);
391
			lapb->state   = LAPB_STATE_4;
392
			lapb->n2count = 0;
393
			break;
394
		}
395
		if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION)
396
			lapb_frames_acked(lapb, frame->nr);
397
		else
398
			lapb_check_iframes_acked(lapb, frame->nr);
399

400
		if (frame->ns == lapb->vr) {
401
			int cn;
402
			cn = lapb_data_indication(lapb, skb);
403
			queued = 1;
404
			/*
405
			 * If upper layer has dropped the frame, we
406
			 * basically ignore any further protocol
407
			 * processing. This will cause the peer
408
			 * to re-transmit the frame later like
409
			 * a frame lost on the wire.
410
			 */
411
			if (cn == NET_RX_DROP) {
412
				pr_debug("rx congestion\n");
413
				break;
414
			}
415
			lapb->vr = (lapb->vr + 1) % modulus;
416
			lapb->condition &= ~LAPB_REJECT_CONDITION;
417
			if (frame->pf)
418
				lapb_enquiry_response(lapb);
419
			else {
420
				if (!(lapb->condition &
421
				      LAPB_ACK_PENDING_CONDITION)) {
422
					lapb->condition |= LAPB_ACK_PENDING_CONDITION;
423
					lapb_start_t2timer(lapb);
424
				}
425
			}
426
		} else {
427
			if (lapb->condition & LAPB_REJECT_CONDITION) {
428
				if (frame->pf)
429
					lapb_enquiry_response(lapb);
430
			} else {
431
				lapb_dbg(1, "(%p) S3 TX REJ(%d) R%d\n",
432
					 lapb->dev, frame->pf, lapb->vr);
433
				lapb->condition |= LAPB_REJECT_CONDITION;
434
				lapb_send_control(lapb, LAPB_REJ, frame->pf,
435
						  LAPB_RESPONSE);
436
				lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
437
			}
438
		}
439
		break;
440

441
	case LAPB_FRMR:
442
		lapb_dbg(1, "(%p) S3 RX FRMR(%d) %5ph\n",
443
			 lapb->dev, frame->pf,
444
			 skb->data);
445
		lapb_establish_data_link(lapb);
446
		lapb_dbg(0, "(%p) S3 -> S1\n", lapb->dev);
447
		lapb_requeue_frames(lapb);
448
		lapb->state = LAPB_STATE_1;
449
		break;
450

451
	case LAPB_ILLEGAL:
452
		lapb_dbg(1, "(%p) S3 RX ILLEGAL(%d)\n", lapb->dev, frame->pf);
453
		lapb->frmr_data = *frame;
454
		lapb->frmr_type = LAPB_FRMR_W;
455
		lapb_transmit_frmr(lapb);
456
		lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
457
		lapb_start_t1timer(lapb);
458
		lapb_stop_t2timer(lapb);
459
		lapb->state   = LAPB_STATE_4;
460
		lapb->n2count = 0;
461
		break;
462
	}
463

464
	if (!queued)
465
		kfree_skb(skb);
466
}
467

468
/*
469
 *	State machine for state 4, Frame Reject State.
470
 *	The handling of the timer(s) is in file lapb_timer.c.
471
 */
472
static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb,
473
				struct lapb_frame *frame)
474
{
475
	switch (frame->type) {
476
	case LAPB_SABM:
477
		lapb_dbg(1, "(%p) S4 RX SABM(%d)\n", lapb->dev, frame->pf);
478
		if (lapb->mode & LAPB_EXTENDED) {
479
			lapb_dbg(1, "(%p) S4 TX DM(%d)\n",
480
				 lapb->dev, frame->pf);
481
			lapb_send_control(lapb, LAPB_DM, frame->pf,
482
					  LAPB_RESPONSE);
483
		} else {
484
			lapb_dbg(1, "(%p) S4 TX UA(%d)\n",
485
				 lapb->dev, frame->pf);
486
			lapb_dbg(0, "(%p) S4 -> S3\n", lapb->dev);
487
			lapb_send_control(lapb, LAPB_UA, frame->pf,
488
					  LAPB_RESPONSE);
489
			lapb_stop_t1timer(lapb);
490
			lapb_stop_t2timer(lapb);
491
			lapb->state     = LAPB_STATE_3;
492
			lapb->condition = 0x00;
493
			lapb->n2count   = 0;
494
			lapb->vs        = 0;
495
			lapb->vr        = 0;
496
			lapb->va        = 0;
497
			lapb_connect_indication(lapb, LAPB_OK);
498
		}
499
		break;
500

501
	case LAPB_SABME:
502
		lapb_dbg(1, "(%p) S4 RX SABME(%d)\n", lapb->dev, frame->pf);
503
		if (lapb->mode & LAPB_EXTENDED) {
504
			lapb_dbg(1, "(%p) S4 TX UA(%d)\n",
505
				 lapb->dev, frame->pf);
506
			lapb_dbg(0, "(%p) S4 -> S3\n", lapb->dev);
507
			lapb_send_control(lapb, LAPB_UA, frame->pf,
508
					  LAPB_RESPONSE);
509
			lapb_stop_t1timer(lapb);
510
			lapb_stop_t2timer(lapb);
511
			lapb->state     = LAPB_STATE_3;
512
			lapb->condition = 0x00;
513
			lapb->n2count   = 0;
514
			lapb->vs        = 0;
515
			lapb->vr        = 0;
516
			lapb->va        = 0;
517
			lapb_connect_indication(lapb, LAPB_OK);
518
		} else {
519
			lapb_dbg(1, "(%p) S4 TX DM(%d)\n",
520
				 lapb->dev, frame->pf);
521
			lapb_send_control(lapb, LAPB_DM, frame->pf,
522
					  LAPB_RESPONSE);
523
		}
524
		break;
525
	}
526

527
	kfree_skb(skb);
528
}
529

530
/*
531
 *	Process an incoming LAPB frame
532
 */
533
void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *skb)
534
{
535
	struct lapb_frame frame;
536

537
	if (lapb_decode(lapb, skb, &frame) < 0) {
538
		kfree_skb(skb);
539
		return;
540
	}
541

542
	switch (lapb->state) {
543
	case LAPB_STATE_0:
544
		lapb_state0_machine(lapb, skb, &frame); break;
545
	case LAPB_STATE_1:
546
		lapb_state1_machine(lapb, skb, &frame); break;
547
	case LAPB_STATE_2:
548
		lapb_state2_machine(lapb, skb, &frame); break;
549
	case LAPB_STATE_3:
550
		lapb_state3_machine(lapb, skb, &frame); break;
551
	case LAPB_STATE_4:
552
		lapb_state4_machine(lapb, skb, &frame); break;
553
	}
554

555
	lapb_kick(lapb);
556
}
557

558
Product

Resources

Company
