cfg80211: fix interface combinations check
[linux-2.6.git] / net / lapb / lapb_in.c
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 <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", lapb->dev);
65 #endif
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;
79
80         case LAPB_SABME:
81 #if LAPB_DEBUG > 1
82                 printk(KERN_DEBUG "lapb: (%p) S0 RX SABME(%d)\n",
83                        lapb->dev, frame->pf);
84 #endif
85                 if (lapb->mode & LAPB_EXTENDED) {
86 #if LAPB_DEBUG > 1
87                         printk(KERN_DEBUG "lapb: (%p) S0 TX UA(%d)\n",
88                                lapb->dev, frame->pf);
89 #endif
90 #if LAPB_DEBUG > 0
91                         printk(KERN_DEBUG "lapb: (%p) S0 -> S3\n", lapb->dev);
92 #endif
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);
108 #endif
109                         lapb_send_control(lapb, LAPB_DM, frame->pf,
110                                           LAPB_RESPONSE);
111                 }
112                 break;
113
114         case LAPB_DISC:
115 #if LAPB_DEBUG > 1
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);
120 #endif
121                 lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
122                 break;
123
124         default:
125                 break;
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  */
135 static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb,
136                                 struct lapb_frame *frame)
137 {
138         switch (frame->type) {
139         case LAPB_SABM:
140 #if LAPB_DEBUG > 1
141                 printk(KERN_DEBUG "lapb: (%p) S1 RX SABM(%d)\n",
142                        lapb->dev, frame->pf);
143 #endif
144                 if (lapb->mode & LAPB_EXTENDED) {
145 #if LAPB_DEBUG > 1
146                         printk(KERN_DEBUG "lapb: (%p) S1 TX DM(%d)\n",
147                                lapb->dev, frame->pf);
148 #endif
149                         lapb_send_control(lapb, LAPB_DM, frame->pf,
150                                           LAPB_RESPONSE);
151                 } else {
152 #if LAPB_DEBUG > 1
153                         printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
154                                lapb->dev, frame->pf);
155 #endif
156                         lapb_send_control(lapb, LAPB_UA, frame->pf,
157                                           LAPB_RESPONSE);
158                 }
159                 break;
160
161         case LAPB_SABME:
162 #if LAPB_DEBUG > 1
163                 printk(KERN_DEBUG "lapb: (%p) S1 RX SABME(%d)\n",
164                        lapb->dev, frame->pf);
165 #endif
166                 if (lapb->mode & LAPB_EXTENDED) {
167 #if LAPB_DEBUG > 1
168                         printk(KERN_DEBUG "lapb: (%p) S1 TX UA(%d)\n",
169                                lapb->dev, frame->pf);
170 #endif
171                         lapb_send_control(lapb, LAPB_UA, frame->pf,
172                                           LAPB_RESPONSE);
173                 } else {
174 #if LAPB_DEBUG > 1
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);
180                 }
181                 break;
182
183         case LAPB_DISC:
184 #if LAPB_DEBUG > 1
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);
189 #endif
190                 lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
191                 break;
192
193         case LAPB_UA:
194 #if LAPB_DEBUG > 1
195                 printk(KERN_DEBUG "lapb: (%p) S1 RX UA(%d)\n",
196                        lapb->dev, frame->pf);
197 #endif
198                 if (frame->pf) {
199 #if LAPB_DEBUG > 0
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;
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  */
239 static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb,
240                                 struct lapb_frame *frame)
241 {
242         switch (frame->type) {
243         case LAPB_SABM:
244         case LAPB_SABME:
245 #if LAPB_DEBUG > 1
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);
250 #endif
251                 lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
252                 break;
253
254         case LAPB_DISC:
255 #if LAPB_DEBUG > 1
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);
260 #endif
261                 lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
262                 break;
263
264         case LAPB_UA:
265 #if LAPB_DEBUG > 1
266                 printk(KERN_DEBUG "lapb: (%p) S2 RX UA(%d)\n",
267                        lapb->dev, frame->pf);
268 #endif
269                 if (frame->pf) {
270 #if LAPB_DEBUG > 0
271                         printk(KERN_DEBUG "lapb: (%p) S2 -> S0\n", lapb->dev);
272 #endif
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;
279
280         case LAPB_DM:
281 #if LAPB_DEBUG > 1
282                 printk(KERN_DEBUG "lapb: (%p) S2 RX DM(%d)\n",
283                        lapb->dev, frame->pf);
284 #endif
285                 if (frame->pf) {
286 #if LAPB_DEBUG > 0
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;
295
296         case LAPB_I:
297         case LAPB_REJ:
298         case LAPB_RNR:
299         case LAPB_RR:
300 #if LAPB_DEBUG > 1
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);
305 #endif
306                 if (frame->pf)
307                         lapb_send_control(lapb, LAPB_DM, frame->pf,
308                                           LAPB_RESPONSE);
309                 break;
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  */
319 static 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) {
327         case LAPB_SABM:
328 #if LAPB_DEBUG > 1
329                 printk(KERN_DEBUG "lapb: (%p) S3 RX SABM(%d)\n",
330                        lapb->dev, frame->pf);
331 #endif
332                 if (lapb->mode & LAPB_EXTENDED) {
333 #if LAPB_DEBUG > 1
334                         printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
335                                lapb->dev, frame->pf);
336 #endif
337                         lapb_send_control(lapb, LAPB_DM, frame->pf,
338                                           LAPB_RESPONSE);
339                 } else {
340 #if LAPB_DEBUG > 1
341                         printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
342                                lapb->dev, frame->pf);
343 #endif
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;
356
357         case LAPB_SABME:
358 #if LAPB_DEBUG > 1
359                 printk(KERN_DEBUG "lapb: (%p) S3 RX SABME(%d)\n",
360                        lapb->dev, frame->pf);
361 #endif
362                 if (lapb->mode & LAPB_EXTENDED) {
363 #if LAPB_DEBUG > 1
364                         printk(KERN_DEBUG "lapb: (%p) S3 TX UA(%d)\n",
365                                lapb->dev, frame->pf);
366 #endif
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 {
378 #if LAPB_DEBUG > 1
379                         printk(KERN_DEBUG "lapb: (%p) S3 TX DM(%d)\n",
380                                lapb->dev, frame->pf);
381 #endif
382                         lapb_send_control(lapb, LAPB_DM, frame->pf,
383                                           LAPB_RESPONSE);
384                 }
385                 break;
386
387         case LAPB_DISC:
388 #if LAPB_DEBUG > 1
389                 printk(KERN_DEBUG "lapb: (%p) S3 RX DISC(%d)\n",
390                        lapb->dev, frame->pf);
391 #endif
392 #if LAPB_DEBUG > 0
393                 printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", lapb->dev);
394 #endif
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;
402
403         case LAPB_DM:
404 #if LAPB_DEBUG > 1
405                 printk(KERN_DEBUG "lapb: (%p) S3 RX DM(%d)\n",
406                        lapb->dev, frame->pf);
407 #endif
408 #if LAPB_DEBUG > 0
409                 printk(KERN_DEBUG "lapb: (%p) S3 -> S0\n", lapb->dev);
410 #endif
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;
417
418         case LAPB_RNR:
419 #if LAPB_DEBUG > 1
420                 printk(KERN_DEBUG "lapb: (%p) S3 RX RNR(%d) R%d\n",
421                        lapb->dev, frame->pf, frame->nr);
422 #endif
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);
431 #if LAPB_DEBUG > 0
432                         printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
433 #endif
434                         lapb_start_t1timer(lapb);
435                         lapb_stop_t2timer(lapb);
436                         lapb->state   = LAPB_STATE_4;
437                         lapb->n2count = 0;
438                 }
439                 break;
440
441         case LAPB_RR:
442 #if LAPB_DEBUG > 1
443                 printk(KERN_DEBUG "lapb: (%p) S3 RX RR(%d) R%d\n",
444                        lapb->dev, frame->pf, frame->nr);
445 #endif
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);
454 #if LAPB_DEBUG > 0
455                         printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
456 #endif
457                         lapb_start_t1timer(lapb);
458                         lapb_stop_t2timer(lapb);
459                         lapb->state   = LAPB_STATE_4;
460                         lapb->n2count = 0;
461                 }
462                 break;
463
464         case LAPB_REJ:
465 #if LAPB_DEBUG > 1
466                 printk(KERN_DEBUG "lapb: (%p) S3 RX REJ(%d) R%d\n",
467                        lapb->dev, frame->pf, frame->nr);
468 #endif
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);
480 #if LAPB_DEBUG > 0
481                         printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
482 #endif
483                         lapb_start_t1timer(lapb);
484                         lapb_stop_t2timer(lapb);
485                         lapb->state   = LAPB_STATE_4;
486                         lapb->n2count = 0;
487                 }
488                 break;
489
490         case LAPB_I:
491 #if LAPB_DEBUG > 1
492                 printk(KERN_DEBUG "lapb: (%p) S3 RX I(%d) S%d R%d\n",
493                        lapb->dev, frame->pf, frame->ns, frame->nr);
494 #endif
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);
499 #if LAPB_DEBUG > 0
500                         printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
501 #endif
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");
526                                 break;
527                         }
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);
537                                 }
538                         }
539                 } else {
540                         if (lapb->condition & LAPB_REJECT_CONDITION) {
541                                 if (frame->pf)
542                                         lapb_enquiry_response(lapb);
543                         } else {
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;
553                         }
554                 }
555                 break;
556
557         case LAPB_FRMR:
558 #if LAPB_DEBUG > 1
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]);
563 #endif
564                 lapb_establish_data_link(lapb);
565 #if LAPB_DEBUG > 0
566                 printk(KERN_DEBUG "lapb: (%p) S3 -> S1\n", lapb->dev);
567 #endif
568                 lapb_requeue_frames(lapb);
569                 lapb->state = LAPB_STATE_1;
570                 break;
571
572         case LAPB_ILLEGAL:
573 #if LAPB_DEBUG > 1
574                 printk(KERN_DEBUG "lapb: (%p) S3 RX ILLEGAL(%d)\n",
575                        lapb->dev, frame->pf);
576 #endif
577                 lapb->frmr_data = *frame;
578                 lapb->frmr_type = LAPB_FRMR_W;
579                 lapb_transmit_frmr(lapb);
580 #if LAPB_DEBUG > 0
581                 printk(KERN_DEBUG "lapb: (%p) S3 -> S4\n", lapb->dev);
582 #endif
583                 lapb_start_t1timer(lapb);
584                 lapb_stop_t2timer(lapb);
585                 lapb->state   = LAPB_STATE_4;
586                 lapb->n2count = 0;
587                 break;
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  */
598 static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb,
599                                 struct lapb_frame *frame)
600 {
601         switch (frame->type) {
602         case LAPB_SABM:
603 #if LAPB_DEBUG > 1
604                 printk(KERN_DEBUG "lapb: (%p) S4 RX SABM(%d)\n",
605                        lapb->dev, frame->pf);
606 #endif
607                 if (lapb->mode & LAPB_EXTENDED) {
608 #if LAPB_DEBUG > 1
609                         printk(KERN_DEBUG "lapb: (%p) S4 TX DM(%d)\n",
610                                lapb->dev, frame->pf);
611 #endif
612                         lapb_send_control(lapb, LAPB_DM, frame->pf,
613                                           LAPB_RESPONSE);
614                 } else {
615 #if LAPB_DEBUG > 1
616                         printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
617                                lapb->dev, frame->pf);
618 #endif
619 #if LAPB_DEBUG > 0
620                         printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", lapb->dev);
621 #endif
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;
635
636         case LAPB_SABME:
637 #if LAPB_DEBUG > 1
638                 printk(KERN_DEBUG "lapb: (%p) S4 RX SABME(%d)\n",
639                        lapb->dev, frame->pf);
640 #endif
641                 if (lapb->mode & LAPB_EXTENDED) {
642 #if LAPB_DEBUG > 1
643                         printk(KERN_DEBUG "lapb: (%p) S4 TX UA(%d)\n",
644                                lapb->dev, frame->pf);
645 #endif
646 #if LAPB_DEBUG > 0
647                         printk(KERN_DEBUG "lapb: (%p) S4 -> S3\n", lapb->dev);
648 #endif
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);
664 #endif
665                         lapb_send_control(lapb, LAPB_DM, frame->pf,
666                                           LAPB_RESPONSE);
667                 }
668                 break;
669         }
670
671         kfree_skb(skb);
672 }
673
674 /*
675  *      Process an incoming LAPB frame
676  */
677 void 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 }