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