Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
lapb_in.c
Go to the documentation of this file.
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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19 
20 #include <linux/errno.h>
21 #include <linux/types.h>
22 #include <linux/socket.h>
23 #include <linux/in.h>
24 #include <linux/kernel.h>
25 #include <linux/timer.h>
26 #include <linux/string.h>
27 #include <linux/sockios.h>
28 #include <linux/net.h>
29 #include <linux/inet.h>
30 #include <linux/netdevice.h>
31 #include <linux/skbuff.h>
32 #include <linux/slab.h>
33 #include <net/sock.h>
34 #include <asm/uaccess.h>
35 #include <linux/fcntl.h>
36 #include <linux/mm.h>
37 #include <linux/interrupt.h>
38 #include <net/lapb.h>
39 
40 /*
41  * State machine for state 0, Disconnected State.
42  * The handling of the timer(s) is in file lapb_timer.c.
43  */
44 static void lapb_state0_machine(struct lapb_cb *lapb, struct sk_buff *skb,
45  struct lapb_frame *frame)
46 {
47  switch (frame->type) {
48  case LAPB_SABM:
49  lapb_dbg(1, "(%p) S0 RX SABM(%d)\n", lapb->dev, frame->pf);
50  if (lapb->mode & LAPB_EXTENDED) {
51  lapb_dbg(1, "(%p) S0 TX DM(%d)\n",
52  lapb->dev, frame->pf);
53  lapb_send_control(lapb, LAPB_DM, frame->pf,
54  LAPB_RESPONSE);
55  } else {
56  lapb_dbg(1, "(%p) S0 TX UA(%d)\n",
57  lapb->dev, frame->pf);
58  lapb_dbg(0, "(%p) S0 -> S3\n", lapb->dev);
59  lapb_send_control(lapb, LAPB_UA, frame->pf,
60  LAPB_RESPONSE);
61  lapb_stop_t1timer(lapb);
62  lapb_stop_t2timer(lapb);
63  lapb->state = LAPB_STATE_3;
64  lapb->condition = 0x00;
65  lapb->n2count = 0;
66  lapb->vs = 0;
67  lapb->vr = 0;
68  lapb->va = 0;
69  lapb_connect_indication(lapb, LAPB_OK);
70  }
71  break;
72 
73  case LAPB_SABME:
74  lapb_dbg(1, "(%p) S0 RX SABME(%d)\n", lapb->dev, frame->pf);
75  if (lapb->mode & LAPB_EXTENDED) {
76  lapb_dbg(1, "(%p) S0 TX UA(%d)\n",
77  lapb->dev, frame->pf);
78  lapb_dbg(0, "(%p) S0 -> S3\n", lapb->dev);
79  lapb_send_control(lapb, LAPB_UA, frame->pf,
80  LAPB_RESPONSE);
81  lapb_stop_t1timer(lapb);
82  lapb_stop_t2timer(lapb);
83  lapb->state = LAPB_STATE_3;
84  lapb->condition = 0x00;
85  lapb->n2count = 0;
86  lapb->vs = 0;
87  lapb->vr = 0;
88  lapb->va = 0;
89  lapb_connect_indication(lapb, LAPB_OK);
90  } else {
91  lapb_dbg(1, "(%p) S0 TX DM(%d)\n",
92  lapb->dev, frame->pf);
93  lapb_send_control(lapb, LAPB_DM, frame->pf,
94  LAPB_RESPONSE);
95  }
96  break;
97 
98  case LAPB_DISC:
99  lapb_dbg(1, "(%p) S0 RX DISC(%d)\n", lapb->dev, frame->pf);
100  lapb_dbg(1, "(%p) S0 TX UA(%d)\n", lapb->dev, frame->pf);
101  lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
102  break;
103 
104  default:
105  break;
106  }
107 
108  kfree_skb(skb);
109 }
110 
111 /*
112  * State machine for state 1, Awaiting Connection State.
113  * The handling of the timer(s) is in file lapb_timer.c.
114  */
115 static void lapb_state1_machine(struct lapb_cb *lapb, struct sk_buff *skb,
116  struct lapb_frame *frame)
117 {
118  switch (frame->type) {
119  case LAPB_SABM:
120  lapb_dbg(1, "(%p) S1 RX SABM(%d)\n", lapb->dev, frame->pf);
121  if (lapb->mode & LAPB_EXTENDED) {
122  lapb_dbg(1, "(%p) S1 TX DM(%d)\n",
123  lapb->dev, frame->pf);
124  lapb_send_control(lapb, LAPB_DM, frame->pf,
125  LAPB_RESPONSE);
126  } else {
127  lapb_dbg(1, "(%p) S1 TX UA(%d)\n",
128  lapb->dev, frame->pf);
129  lapb_send_control(lapb, LAPB_UA, frame->pf,
130  LAPB_RESPONSE);
131  }
132  break;
133 
134  case LAPB_SABME:
135  lapb_dbg(1, "(%p) S1 RX SABME(%d)\n", lapb->dev, frame->pf);
136  if (lapb->mode & LAPB_EXTENDED) {
137  lapb_dbg(1, "(%p) S1 TX UA(%d)\n",
138  lapb->dev, frame->pf);
139  lapb_send_control(lapb, LAPB_UA, frame->pf,
140  LAPB_RESPONSE);
141  } else {
142  lapb_dbg(1, "(%p) S1 TX DM(%d)\n",
143  lapb->dev, frame->pf);
144  lapb_send_control(lapb, LAPB_DM, frame->pf,
145  LAPB_RESPONSE);
146  }
147  break;
148 
149  case LAPB_DISC:
150  lapb_dbg(1, "(%p) S1 RX DISC(%d)\n", lapb->dev, frame->pf);
151  lapb_dbg(1, "(%p) S1 TX DM(%d)\n", lapb->dev, frame->pf);
152  lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
153  break;
154 
155  case LAPB_UA:
156  lapb_dbg(1, "(%p) S1 RX UA(%d)\n", lapb->dev, frame->pf);
157  if (frame->pf) {
158  lapb_dbg(0, "(%p) S1 -> S3\n", lapb->dev);
159  lapb_stop_t1timer(lapb);
160  lapb_stop_t2timer(lapb);
161  lapb->state = LAPB_STATE_3;
162  lapb->condition = 0x00;
163  lapb->n2count = 0;
164  lapb->vs = 0;
165  lapb->vr = 0;
166  lapb->va = 0;
167  lapb_connect_confirmation(lapb, LAPB_OK);
168  }
169  break;
170 
171  case LAPB_DM:
172  lapb_dbg(1, "(%p) S1 RX DM(%d)\n", lapb->dev, frame->pf);
173  if (frame->pf) {
174  lapb_dbg(0, "(%p) S1 -> S0\n", lapb->dev);
175  lapb_clear_queues(lapb);
176  lapb->state = LAPB_STATE_0;
177  lapb_start_t1timer(lapb);
178  lapb_stop_t2timer(lapb);
179  lapb_disconnect_indication(lapb, LAPB_REFUSED);
180  }
181  break;
182  }
183 
184  kfree_skb(skb);
185 }
186 
187 /*
188  * State machine for state 2, Awaiting Release State.
189  * The handling of the timer(s) is in file lapb_timer.c
190  */
191 static void lapb_state2_machine(struct lapb_cb *lapb, struct sk_buff *skb,
192  struct lapb_frame *frame)
193 {
194  switch (frame->type) {
195  case LAPB_SABM:
196  case LAPB_SABME:
197  lapb_dbg(1, "(%p) S2 RX {SABM,SABME}(%d)\n",
198  lapb->dev, frame->pf);
199  lapb_dbg(1, "(%p) S2 TX DM(%d)\n", lapb->dev, frame->pf);
200  lapb_send_control(lapb, LAPB_DM, frame->pf, LAPB_RESPONSE);
201  break;
202 
203  case LAPB_DISC:
204  lapb_dbg(1, "(%p) S2 RX DISC(%d)\n", lapb->dev, frame->pf);
205  lapb_dbg(1, "(%p) S2 TX UA(%d)\n", lapb->dev, frame->pf);
206  lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
207  break;
208 
209  case LAPB_UA:
210  lapb_dbg(1, "(%p) S2 RX UA(%d)\n", lapb->dev, frame->pf);
211  if (frame->pf) {
212  lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev);
213  lapb->state = LAPB_STATE_0;
214  lapb_start_t1timer(lapb);
215  lapb_stop_t2timer(lapb);
216  lapb_disconnect_confirmation(lapb, LAPB_OK);
217  }
218  break;
219 
220  case LAPB_DM:
221  lapb_dbg(1, "(%p) S2 RX DM(%d)\n", lapb->dev, frame->pf);
222  if (frame->pf) {
223  lapb_dbg(0, "(%p) S2 -> S0\n", lapb->dev);
224  lapb->state = LAPB_STATE_0;
225  lapb_start_t1timer(lapb);
226  lapb_stop_t2timer(lapb);
227  lapb_disconnect_confirmation(lapb, LAPB_NOTCONNECTED);
228  }
229  break;
230 
231  case LAPB_I:
232  case LAPB_REJ:
233  case LAPB_RNR:
234  case LAPB_RR:
235  lapb_dbg(1, "(%p) S2 RX {I,REJ,RNR,RR}(%d)\n",
236  lapb->dev, frame->pf);
237  lapb_dbg(1, "(%p) S2 RX DM(%d)\n", lapb->dev, frame->pf);
238  if (frame->pf)
239  lapb_send_control(lapb, LAPB_DM, frame->pf,
240  LAPB_RESPONSE);
241  break;
242  }
243 
244  kfree_skb(skb);
245 }
246 
247 /*
248  * State machine for state 3, Connected State.
249  * The handling of the timer(s) is in file lapb_timer.c
250  */
251 static void lapb_state3_machine(struct lapb_cb *lapb, struct sk_buff *skb,
252  struct lapb_frame *frame)
253 {
254  int queued = 0;
255  int modulus = (lapb->mode & LAPB_EXTENDED) ? LAPB_EMODULUS :
256  LAPB_SMODULUS;
257 
258  switch (frame->type) {
259  case LAPB_SABM:
260  lapb_dbg(1, "(%p) S3 RX SABM(%d)\n", lapb->dev, frame->pf);
261  if (lapb->mode & LAPB_EXTENDED) {
262  lapb_dbg(1, "(%p) S3 TX DM(%d)\n",
263  lapb->dev, frame->pf);
264  lapb_send_control(lapb, LAPB_DM, frame->pf,
265  LAPB_RESPONSE);
266  } else {
267  lapb_dbg(1, "(%p) S3 TX UA(%d)\n",
268  lapb->dev, frame->pf);
269  lapb_send_control(lapb, LAPB_UA, frame->pf,
270  LAPB_RESPONSE);
271  lapb_stop_t1timer(lapb);
272  lapb_stop_t2timer(lapb);
273  lapb->condition = 0x00;
274  lapb->n2count = 0;
275  lapb->vs = 0;
276  lapb->vr = 0;
277  lapb->va = 0;
278  lapb_requeue_frames(lapb);
279  }
280  break;
281 
282  case LAPB_SABME:
283  lapb_dbg(1, "(%p) S3 RX SABME(%d)\n", lapb->dev, frame->pf);
284  if (lapb->mode & LAPB_EXTENDED) {
285  lapb_dbg(1, "(%p) S3 TX UA(%d)\n",
286  lapb->dev, frame->pf);
287  lapb_send_control(lapb, LAPB_UA, frame->pf,
288  LAPB_RESPONSE);
289  lapb_stop_t1timer(lapb);
290  lapb_stop_t2timer(lapb);
291  lapb->condition = 0x00;
292  lapb->n2count = 0;
293  lapb->vs = 0;
294  lapb->vr = 0;
295  lapb->va = 0;
296  lapb_requeue_frames(lapb);
297  } else {
298  lapb_dbg(1, "(%p) S3 TX DM(%d)\n",
299  lapb->dev, frame->pf);
300  lapb_send_control(lapb, LAPB_DM, frame->pf,
301  LAPB_RESPONSE);
302  }
303  break;
304 
305  case LAPB_DISC:
306  lapb_dbg(1, "(%p) S3 RX DISC(%d)\n", lapb->dev, frame->pf);
307  lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev);
308  lapb_clear_queues(lapb);
309  lapb_send_control(lapb, LAPB_UA, frame->pf, LAPB_RESPONSE);
310  lapb_start_t1timer(lapb);
311  lapb_stop_t2timer(lapb);
312  lapb->state = LAPB_STATE_0;
313  lapb_disconnect_indication(lapb, LAPB_OK);
314  break;
315 
316  case LAPB_DM:
317  lapb_dbg(1, "(%p) S3 RX DM(%d)\n", lapb->dev, frame->pf);
318  lapb_dbg(0, "(%p) S3 -> S0\n", lapb->dev);
319  lapb_clear_queues(lapb);
320  lapb->state = LAPB_STATE_0;
321  lapb_start_t1timer(lapb);
322  lapb_stop_t2timer(lapb);
323  lapb_disconnect_indication(lapb, LAPB_NOTCONNECTED);
324  break;
325 
326  case LAPB_RNR:
327  lapb_dbg(1, "(%p) S3 RX RNR(%d) R%d\n",
328  lapb->dev, frame->pf, frame->nr);
329  lapb->condition |= LAPB_PEER_RX_BUSY_CONDITION;
330  lapb_check_need_response(lapb, frame->cr, frame->pf);
331  if (lapb_validate_nr(lapb, frame->nr)) {
332  lapb_check_iframes_acked(lapb, frame->nr);
333  } else {
334  lapb->frmr_data = *frame;
335  lapb->frmr_type = LAPB_FRMR_Z;
336  lapb_transmit_frmr(lapb);
337  lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
338  lapb_start_t1timer(lapb);
339  lapb_stop_t2timer(lapb);
340  lapb->state = LAPB_STATE_4;
341  lapb->n2count = 0;
342  }
343  break;
344 
345  case LAPB_RR:
346  lapb_dbg(1, "(%p) S3 RX RR(%d) R%d\n",
347  lapb->dev, frame->pf, frame->nr);
348  lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
349  lapb_check_need_response(lapb, frame->cr, frame->pf);
350  if (lapb_validate_nr(lapb, frame->nr)) {
351  lapb_check_iframes_acked(lapb, frame->nr);
352  } else {
353  lapb->frmr_data = *frame;
354  lapb->frmr_type = LAPB_FRMR_Z;
355  lapb_transmit_frmr(lapb);
356  lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
357  lapb_start_t1timer(lapb);
358  lapb_stop_t2timer(lapb);
359  lapb->state = LAPB_STATE_4;
360  lapb->n2count = 0;
361  }
362  break;
363 
364  case LAPB_REJ:
365  lapb_dbg(1, "(%p) S3 RX REJ(%d) R%d\n",
366  lapb->dev, frame->pf, frame->nr);
367  lapb->condition &= ~LAPB_PEER_RX_BUSY_CONDITION;
368  lapb_check_need_response(lapb, frame->cr, frame->pf);
369  if (lapb_validate_nr(lapb, frame->nr)) {
370  lapb_frames_acked(lapb, frame->nr);
371  lapb_stop_t1timer(lapb);
372  lapb->n2count = 0;
373  lapb_requeue_frames(lapb);
374  } else {
375  lapb->frmr_data = *frame;
376  lapb->frmr_type = LAPB_FRMR_Z;
377  lapb_transmit_frmr(lapb);
378  lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
379  lapb_start_t1timer(lapb);
380  lapb_stop_t2timer(lapb);
381  lapb->state = LAPB_STATE_4;
382  lapb->n2count = 0;
383  }
384  break;
385 
386  case LAPB_I:
387  lapb_dbg(1, "(%p) S3 RX I(%d) S%d R%d\n",
388  lapb->dev, frame->pf, frame->ns, frame->nr);
389  if (!lapb_validate_nr(lapb, frame->nr)) {
390  lapb->frmr_data = *frame;
391  lapb->frmr_type = LAPB_FRMR_Z;
392  lapb_transmit_frmr(lapb);
393  lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
394  lapb_start_t1timer(lapb);
395  lapb_stop_t2timer(lapb);
396  lapb->state = LAPB_STATE_4;
397  lapb->n2count = 0;
398  break;
399  }
400  if (lapb->condition & LAPB_PEER_RX_BUSY_CONDITION)
401  lapb_frames_acked(lapb, frame->nr);
402  else
403  lapb_check_iframes_acked(lapb, frame->nr);
404 
405  if (frame->ns == lapb->vr) {
406  int cn;
407  cn = lapb_data_indication(lapb, skb);
408  queued = 1;
409  /*
410  * If upper layer has dropped the frame, we
411  * basically ignore any further protocol
412  * processing. This will cause the peer
413  * to re-transmit the frame later like
414  * a frame lost on the wire.
415  */
416  if (cn == NET_RX_DROP) {
417  pr_debug("rx congestion\n");
418  break;
419  }
420  lapb->vr = (lapb->vr + 1) % modulus;
421  lapb->condition &= ~LAPB_REJECT_CONDITION;
422  if (frame->pf)
423  lapb_enquiry_response(lapb);
424  else {
425  if (!(lapb->condition &
426  LAPB_ACK_PENDING_CONDITION)) {
427  lapb->condition |= LAPB_ACK_PENDING_CONDITION;
428  lapb_start_t2timer(lapb);
429  }
430  }
431  } else {
432  if (lapb->condition & LAPB_REJECT_CONDITION) {
433  if (frame->pf)
434  lapb_enquiry_response(lapb);
435  } else {
436  lapb_dbg(1, "(%p) S3 TX REJ(%d) R%d\n",
437  lapb->dev, frame->pf, lapb->vr);
438  lapb->condition |= LAPB_REJECT_CONDITION;
439  lapb_send_control(lapb, LAPB_REJ, frame->pf,
440  LAPB_RESPONSE);
441  lapb->condition &= ~LAPB_ACK_PENDING_CONDITION;
442  }
443  }
444  break;
445 
446  case LAPB_FRMR:
447  lapb_dbg(1, "(%p) S3 RX FRMR(%d) %02X %02X %02X %02X %02X\n",
448  lapb->dev, frame->pf,
449  skb->data[0], skb->data[1], skb->data[2],
450  skb->data[3], skb->data[4]);
451  lapb_establish_data_link(lapb);
452  lapb_dbg(0, "(%p) S3 -> S1\n", lapb->dev);
453  lapb_requeue_frames(lapb);
454  lapb->state = LAPB_STATE_1;
455  break;
456 
457  case LAPB_ILLEGAL:
458  lapb_dbg(1, "(%p) S3 RX ILLEGAL(%d)\n", lapb->dev, frame->pf);
459  lapb->frmr_data = *frame;
460  lapb->frmr_type = LAPB_FRMR_W;
461  lapb_transmit_frmr(lapb);
462  lapb_dbg(0, "(%p) S3 -> S4\n", lapb->dev);
463  lapb_start_t1timer(lapb);
464  lapb_stop_t2timer(lapb);
465  lapb->state = LAPB_STATE_4;
466  lapb->n2count = 0;
467  break;
468  }
469 
470  if (!queued)
471  kfree_skb(skb);
472 }
473 
474 /*
475  * State machine for state 4, Frame Reject State.
476  * The handling of the timer(s) is in file lapb_timer.c.
477  */
478 static void lapb_state4_machine(struct lapb_cb *lapb, struct sk_buff *skb,
479  struct lapb_frame *frame)
480 {
481  switch (frame->type) {
482  case LAPB_SABM:
483  lapb_dbg(1, "(%p) S4 RX SABM(%d)\n", lapb->dev, frame->pf);
484  if (lapb->mode & LAPB_EXTENDED) {
485  lapb_dbg(1, "(%p) S4 TX DM(%d)\n",
486  lapb->dev, frame->pf);
487  lapb_send_control(lapb, LAPB_DM, frame->pf,
488  LAPB_RESPONSE);
489  } else {
490  lapb_dbg(1, "(%p) S4 TX UA(%d)\n",
491  lapb->dev, frame->pf);
492  lapb_dbg(0, "(%p) S4 -> S3\n", lapb->dev);
493  lapb_send_control(lapb, LAPB_UA, frame->pf,
494  LAPB_RESPONSE);
495  lapb_stop_t1timer(lapb);
496  lapb_stop_t2timer(lapb);
497  lapb->state = LAPB_STATE_3;
498  lapb->condition = 0x00;
499  lapb->n2count = 0;
500  lapb->vs = 0;
501  lapb->vr = 0;
502  lapb->va = 0;
503  lapb_connect_indication(lapb, LAPB_OK);
504  }
505  break;
506 
507  case LAPB_SABME:
508  lapb_dbg(1, "(%p) S4 RX SABME(%d)\n", lapb->dev, frame->pf);
509  if (lapb->mode & LAPB_EXTENDED) {
510  lapb_dbg(1, "(%p) S4 TX UA(%d)\n",
511  lapb->dev, frame->pf);
512  lapb_dbg(0, "(%p) S4 -> S3\n", lapb->dev);
513  lapb_send_control(lapb, LAPB_UA, frame->pf,
514  LAPB_RESPONSE);
515  lapb_stop_t1timer(lapb);
516  lapb_stop_t2timer(lapb);
517  lapb->state = LAPB_STATE_3;
518  lapb->condition = 0x00;
519  lapb->n2count = 0;
520  lapb->vs = 0;
521  lapb->vr = 0;
522  lapb->va = 0;
523  lapb_connect_indication(lapb, LAPB_OK);
524  } else {
525  lapb_dbg(1, "(%p) S4 TX DM(%d)\n",
526  lapb->dev, frame->pf);
527  lapb_send_control(lapb, LAPB_DM, frame->pf,
528  LAPB_RESPONSE);
529  }
530  break;
531  }
532 
533  kfree_skb(skb);
534 }
535 
536 /*
537  * Process an incoming LAPB frame
538  */
539 void lapb_data_input(struct lapb_cb *lapb, struct sk_buff *skb)
540 {
541  struct lapb_frame frame;
542 
543  if (lapb_decode(lapb, skb, &frame) < 0) {
544  kfree_skb(skb);
545  return;
546  }
547 
548  switch (lapb->state) {
549  case LAPB_STATE_0:
550  lapb_state0_machine(lapb, skb, &frame); break;
551  case LAPB_STATE_1:
552  lapb_state1_machine(lapb, skb, &frame); break;
553  case LAPB_STATE_2:
554  lapb_state2_machine(lapb, skb, &frame); break;
555  case LAPB_STATE_3:
556  lapb_state3_machine(lapb, skb, &frame); break;
557  case LAPB_STATE_4:
558  lapb_state4_machine(lapb, skb, &frame); break;
559  }
560 
561  lapb_kick(lapb);
562 }
Generated on Thu Jan 10 2013 14:59:51 for Linux Kernel by   doxygen 1.8.2