[LLC]: Simplify llc_c_ac code, removing unneeded assignments to variables
[linux-2.6.git] / net / llc / llc_c_ac.c
1 /*
2  * llc_c_ac.c - actions performed during connection state transition.
3  *
4  * Description:
5  *   Functions in this module are implementation of connection component actions
6  *   Details of actions can be found in IEEE-802.2 standard document.
7  *   All functions have one connection and one event as input argument. All of
8  *   them return 0 On success and 1 otherwise.
9  *
10  * Copyright (c) 1997 by Procom Technology, Inc.
11  *               2001-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
12  *
13  * This program can be redistributed or modified under the terms of the
14  * GNU General Public License as published by the Free Software Foundation.
15  * This program is distributed without any warranty or implied warranty
16  * of merchantability or fitness for a particular purpose.
17  *
18  * See the GNU General Public License for more details.
19  */
20 #include <linux/netdevice.h>
21 #include <net/llc_conn.h>
22 #include <net/llc_sap.h>
23 #include <net/sock.h>
24 #include <net/llc_c_ev.h>
25 #include <net/llc_c_ac.h>
26 #include <net/llc_c_st.h>
27 #include <net/llc_pdu.h>
28 #include <net/llc.h>
29
30 #include "llc_output.h"
31
32 static int llc_conn_ac_inc_vs_by_1(struct sock *sk, struct sk_buff *skb);
33 static void llc_process_tmr_ev(struct sock *sk, struct sk_buff *skb);
34 static int llc_conn_ac_data_confirm(struct sock *sk, struct sk_buff *ev);
35
36 static int llc_conn_ac_inc_npta_value(struct sock *sk, struct sk_buff *skb);
37
38 static int llc_conn_ac_send_rr_rsp_f_set_ackpf(struct sock *sk,
39                                                struct sk_buff *skb);
40
41 static int llc_conn_ac_set_p_flag_1(struct sock *sk, struct sk_buff *skb);
42
43 #define INCORRECT 0
44
45 int llc_conn_ac_clear_remote_busy(struct sock *sk, struct sk_buff *skb)
46 {
47         struct llc_sock *llc = llc_sk(sk);
48
49         if (llc->remote_busy_flag) {
50                 u8 nr;
51                 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
52
53                 llc->remote_busy_flag = 0;
54                 del_timer(&llc->busy_state_timer.timer);
55                 nr = LLC_I_GET_NR(pdu);
56                 llc_conn_resend_i_pdu_as_cmd(sk, nr, 0);
57         }
58         return 0;
59 }
60
61 int llc_conn_ac_conn_ind(struct sock *sk, struct sk_buff *skb)
62 {
63         int rc = -ENOTCONN;
64         u8 dsap;
65         struct llc_sap *sap;
66
67         llc_pdu_decode_dsap(skb, &dsap);
68         sap = llc_sap_find(dsap);
69         if (sap) {
70                 struct llc_conn_state_ev *ev = llc_conn_ev(skb);
71                 struct llc_sock *llc = llc_sk(sk);
72
73                 llc_pdu_decode_sa(skb, llc->daddr.mac);
74                 llc_pdu_decode_da(skb, llc->laddr.mac);
75                 llc->dev = skb->dev;
76                 ev->ind_prim = LLC_CONN_PRIM;
77                 rc = 0;
78         }
79         return rc;
80 }
81
82 int llc_conn_ac_conn_confirm(struct sock *sk, struct sk_buff *skb)
83 {
84         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
85
86         ev->cfm_prim = LLC_CONN_PRIM;
87         return 0;
88 }
89
90 static int llc_conn_ac_data_confirm(struct sock *sk, struct sk_buff *skb)
91 {
92         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
93
94         ev->cfm_prim = LLC_DATA_PRIM;
95         return 0;
96 }
97
98 int llc_conn_ac_data_ind(struct sock *sk, struct sk_buff *skb)
99 {
100         llc_conn_rtn_pdu(sk, skb);
101         return 0;
102 }
103
104 int llc_conn_ac_disc_ind(struct sock *sk, struct sk_buff *skb)
105 {
106         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
107         u8 reason = 0;
108         int rc = 0;
109
110         if (ev->type == LLC_CONN_EV_TYPE_PDU) {
111                 struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
112
113                 if (LLC_PDU_IS_RSP(pdu) &&
114                     LLC_PDU_TYPE_IS_U(pdu) &&
115                     LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_DM)
116                         reason = LLC_DISC_REASON_RX_DM_RSP_PDU;
117                 else if (LLC_PDU_IS_CMD(pdu) &&
118                            LLC_PDU_TYPE_IS_U(pdu) &&
119                            LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_DISC)
120                         reason = LLC_DISC_REASON_RX_DISC_CMD_PDU;
121         } else if (ev->type == LLC_CONN_EV_TYPE_ACK_TMR)
122                 reason = LLC_DISC_REASON_ACK_TMR_EXP;
123         else
124                 rc = -EINVAL;
125         if (!rc) {
126                 ev->reason   = reason;
127                 ev->ind_prim = LLC_DISC_PRIM;
128         }
129         return rc;
130 }
131
132 int llc_conn_ac_disc_confirm(struct sock *sk, struct sk_buff *skb)
133 {
134         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
135
136         ev->reason   = ev->status;
137         ev->cfm_prim = LLC_DISC_PRIM;
138         return 0;
139 }
140
141 int llc_conn_ac_rst_ind(struct sock *sk, struct sk_buff *skb)
142 {
143         u8 reason = 0;
144         int rc = 1;
145         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
146         struct llc_pdu_un *pdu = llc_pdu_un_hdr(skb);
147         struct llc_sock *llc = llc_sk(sk);
148
149         switch (ev->type) {
150         case LLC_CONN_EV_TYPE_PDU:
151                 if (LLC_PDU_IS_RSP(pdu) &&
152                     LLC_PDU_TYPE_IS_U(pdu) &&
153                     LLC_U_PDU_RSP(pdu) == LLC_2_PDU_RSP_FRMR) {
154                         reason = LLC_RESET_REASON_LOCAL;
155                         rc = 0;
156                 } else if (LLC_PDU_IS_CMD(pdu) &&
157                            LLC_PDU_TYPE_IS_U(pdu) &&
158                            LLC_U_PDU_CMD(pdu) == LLC_2_PDU_CMD_SABME) {
159                         reason = LLC_RESET_REASON_REMOTE;
160                         rc = 0;
161                 }
162                 break;
163         case LLC_CONN_EV_TYPE_ACK_TMR:
164         case LLC_CONN_EV_TYPE_P_TMR:
165         case LLC_CONN_EV_TYPE_REJ_TMR:
166         case LLC_CONN_EV_TYPE_BUSY_TMR:
167                 if (llc->retry_count > llc->n2) {
168                         reason = LLC_RESET_REASON_LOCAL;
169                         rc = 0;
170                 }
171                 break;
172         }
173         if (!rc) {
174                 ev->reason   = reason;
175                 ev->ind_prim = LLC_RESET_PRIM;
176         }
177         return rc;
178 }
179
180 int llc_conn_ac_rst_confirm(struct sock *sk, struct sk_buff *skb)
181 {
182         struct llc_conn_state_ev *ev = llc_conn_ev(skb);
183
184         ev->reason   = 0;
185         ev->cfm_prim = LLC_RESET_PRIM;
186         return 0;
187 }
188
189 int llc_conn_ac_clear_remote_busy_if_f_eq_1(struct sock *sk,
190                                             struct sk_buff *skb)
191 {
192         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
193
194         if (LLC_PDU_IS_RSP(pdu) &&
195             LLC_PDU_TYPE_IS_I(pdu) &&
196             LLC_I_PF_IS_1(pdu) && llc_sk(sk)->ack_pf)
197                 llc_conn_ac_clear_remote_busy(sk, skb);
198         return 0;
199 }
200
201 int llc_conn_ac_stop_rej_tmr_if_data_flag_eq_2(struct sock *sk,
202                                                struct sk_buff *skb)
203 {
204         struct llc_sock *llc = llc_sk(sk);
205
206         if (llc->data_flag == 2)
207                 del_timer(&llc->rej_sent_timer.timer);
208         return 0;
209 }
210
211 int llc_conn_ac_send_disc_cmd_p_set_x(struct sock *sk, struct sk_buff *skb)
212 {
213         int rc = -ENOBUFS;
214         struct llc_sock *llc = llc_sk(sk);
215         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
216
217         if (nskb) {
218                 struct llc_sap *sap = llc->sap;
219
220                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
221                                     llc->daddr.lsap, LLC_PDU_CMD);
222                 llc_pdu_init_as_disc_cmd(nskb, 1);
223                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
224                 if (rc)
225                         goto free;
226                 llc_conn_send_pdu(sk, nskb);
227                 llc_conn_ac_set_p_flag_1(sk, skb);
228         }
229 out:
230         return rc;
231 free:
232         kfree_skb(nskb);
233         goto out;
234 }
235
236 int llc_conn_ac_send_dm_rsp_f_set_p(struct sock *sk, struct sk_buff *skb)
237 {
238         int rc = -ENOBUFS;
239         struct llc_sock *llc = llc_sk(sk);
240         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
241
242         if (nskb) {
243                 struct llc_sap *sap = llc->sap;
244                 u8 f_bit;
245
246                 llc_pdu_decode_pf_bit(skb, &f_bit);
247                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
248                                     llc->daddr.lsap, LLC_PDU_RSP);
249                 llc_pdu_init_as_dm_rsp(nskb, f_bit);
250                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
251                 if (rc)
252                         goto free;
253                 llc_conn_send_pdu(sk, nskb);
254         }
255 out:
256         return rc;
257 free:
258         kfree_skb(nskb);
259         goto out;
260 }
261
262 int llc_conn_ac_send_dm_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
263 {
264         int rc = -ENOBUFS;
265         struct llc_sock *llc = llc_sk(sk);
266         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
267
268         if (nskb) {
269                 struct llc_sap *sap = llc->sap;
270                 u8 f_bit = 1;
271
272                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
273                                     llc->daddr.lsap, LLC_PDU_RSP);
274                 llc_pdu_init_as_dm_rsp(nskb, f_bit);
275                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
276                 if (rc)
277                         goto free;
278                 llc_conn_send_pdu(sk, nskb);
279         }
280 out:
281         return rc;
282 free:
283         kfree_skb(nskb);
284         goto out;
285 }
286
287 int llc_conn_ac_send_frmr_rsp_f_set_x(struct sock *sk, struct sk_buff *skb)
288 {
289         u8 f_bit;
290         int rc = -ENOBUFS;
291         struct sk_buff *nskb;
292         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
293         struct llc_sock *llc = llc_sk(sk);
294
295         llc->rx_pdu_hdr = *((u32 *)pdu);
296         if (LLC_PDU_IS_CMD(pdu))
297                 llc_pdu_decode_pf_bit(skb, &f_bit);
298         else
299                 f_bit = 0;
300         nskb = llc_alloc_frame(llc->dev);
301         if (nskb) {
302                 struct llc_sap *sap = llc->sap;
303
304                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
305                                     llc->daddr.lsap, LLC_PDU_RSP);
306                 llc_pdu_init_as_frmr_rsp(nskb, pdu, f_bit, llc->vS,
307                                          llc->vR, INCORRECT);
308                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
309                 if (rc)
310                         goto free;
311                 llc_conn_send_pdu(sk, nskb);
312         }
313 out:
314         return rc;
315 free:
316         kfree_skb(nskb);
317         goto out;
318 }
319
320 int llc_conn_ac_resend_frmr_rsp_f_set_0(struct sock *sk, struct sk_buff *skb)
321 {
322         int rc = -ENOBUFS;
323         struct llc_sock *llc = llc_sk(sk);
324         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
325
326         if (nskb) {
327                 u8 f_bit = 0;
328                 struct llc_sap *sap = llc->sap;
329                 struct llc_pdu_sn *pdu = (struct llc_pdu_sn *)&llc->rx_pdu_hdr;
330
331                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
332                                     llc->daddr.lsap, LLC_PDU_RSP);
333                 llc_pdu_init_as_frmr_rsp(nskb, pdu, f_bit, llc->vS,
334                                          llc->vR, INCORRECT);
335                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
336                 if (rc)
337                         goto free;
338                 llc_conn_send_pdu(sk, nskb);
339         }
340 out:
341         return rc;
342 free:
343         kfree_skb(nskb);
344         goto out;
345 }
346
347 int llc_conn_ac_resend_frmr_rsp_f_set_p(struct sock *sk, struct sk_buff *skb)
348 {
349         u8 f_bit;
350         int rc = -ENOBUFS;
351         struct sk_buff *nskb;
352         struct llc_sock *llc = llc_sk(sk);
353
354         llc_pdu_decode_pf_bit(skb, &f_bit);
355         nskb = llc_alloc_frame(llc->dev);
356         if (nskb) {
357                 struct llc_sap *sap = llc->sap;
358                 struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
359
360                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
361                                     llc->daddr.lsap, LLC_PDU_RSP);
362                 llc_pdu_init_as_frmr_rsp(nskb, pdu, f_bit, llc->vS,
363                                          llc->vR, INCORRECT);
364                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
365                 if (rc)
366                         goto free;
367                 llc_conn_send_pdu(sk, nskb);
368         }
369 out:
370         return rc;
371 free:
372         kfree_skb(nskb);
373         goto out;
374 }
375
376 int llc_conn_ac_send_i_cmd_p_set_1(struct sock *sk, struct sk_buff *skb)
377 {
378         int rc;
379         struct llc_sock *llc = llc_sk(sk);
380         struct llc_sap *sap = llc->sap;
381
382         llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap,
383                             llc->daddr.lsap, LLC_PDU_CMD);
384         llc_pdu_init_as_i_cmd(skb, 1, llc->vS, llc->vR);
385         rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac);
386         if (!rc) {
387                 llc_conn_send_pdu(sk, skb);
388                 llc_conn_ac_inc_vs_by_1(sk, skb);
389         }
390         return rc;
391 }
392
393 static int llc_conn_ac_send_i_cmd_p_set_0(struct sock *sk, struct sk_buff *skb)
394 {
395         int rc;
396         struct llc_sock *llc = llc_sk(sk);
397         struct llc_sap *sap = llc->sap;
398
399         llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap,
400                             llc->daddr.lsap, LLC_PDU_CMD);
401         llc_pdu_init_as_i_cmd(skb, 0, llc->vS, llc->vR);
402         rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac);
403         if (!rc) {
404                 llc_conn_send_pdu(sk, skb);
405                 llc_conn_ac_inc_vs_by_1(sk, skb);
406         }
407         return rc;
408 }
409
410 int llc_conn_ac_send_i_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
411 {
412         int rc;
413         struct llc_sock *llc = llc_sk(sk);
414         struct llc_sap *sap = llc->sap;
415
416         llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap,
417                             llc->daddr.lsap, LLC_PDU_CMD);
418         llc_pdu_init_as_i_cmd(skb, 0, llc->vS, llc->vR);
419         rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac);
420         if (!rc) {
421                 llc_conn_send_pdu(sk, skb);
422                 llc_conn_ac_inc_vs_by_1(sk, skb);
423         }
424         return 0;
425 }
426
427 int llc_conn_ac_resend_i_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
428 {
429         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
430         u8 nr = LLC_I_GET_NR(pdu);
431
432         llc_conn_resend_i_pdu_as_cmd(sk, nr, 0);
433         return 0;
434 }
435
436 int llc_conn_ac_resend_i_xxx_x_set_0_or_send_rr(struct sock *sk,
437                                                 struct sk_buff *skb)
438 {
439         u8 nr;
440         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
441         int rc = -ENOBUFS;
442         struct llc_sock *llc = llc_sk(sk);
443         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
444
445         if (nskb) {
446                 struct llc_sap *sap = llc->sap;
447
448                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
449                                     llc->daddr.lsap, LLC_PDU_RSP);
450                 llc_pdu_init_as_rr_rsp(nskb, 0, llc->vR);
451                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
452                 if (!rc)
453                         llc_conn_send_pdu(sk, nskb);
454                 else
455                         kfree_skb(skb);
456         }
457         if (rc) {
458                 nr = LLC_I_GET_NR(pdu);
459                 rc = 0;
460                 llc_conn_resend_i_pdu_as_cmd(sk, nr, 0);
461         }
462         return rc;
463 }
464
465 int llc_conn_ac_resend_i_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
466 {
467         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
468         u8 nr = LLC_I_GET_NR(pdu);
469
470         llc_conn_resend_i_pdu_as_rsp(sk, nr, 1);
471         return 0;
472 }
473
474 int llc_conn_ac_send_rej_cmd_p_set_1(struct sock *sk, struct sk_buff *skb)
475 {
476         int rc = -ENOBUFS;
477         struct llc_sock *llc = llc_sk(sk);
478         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
479
480         if (nskb) {
481                 struct llc_sap *sap = llc->sap;
482
483                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
484                                     llc->daddr.lsap, LLC_PDU_CMD);
485                 llc_pdu_init_as_rej_cmd(nskb, 1, llc->vR);
486                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
487                 if (rc)
488                         goto free;
489                 llc_conn_send_pdu(sk, nskb);
490         }
491 out:
492         return rc;
493 free:
494         kfree_skb(nskb);
495         goto out;
496 }
497
498 int llc_conn_ac_send_rej_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
499 {
500         int rc = -ENOBUFS;
501         struct llc_sock *llc = llc_sk(sk);
502         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
503
504         if (nskb) {
505                 u8 f_bit = 1;
506                 struct llc_sap *sap = llc->sap;
507
508                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
509                                     llc->daddr.lsap, LLC_PDU_RSP);
510                 llc_pdu_init_as_rej_rsp(nskb, f_bit, llc->vR);
511                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
512                 if (rc)
513                         goto free;
514                 llc_conn_send_pdu(sk, nskb);
515         }
516 out:
517         return rc;
518 free:
519         kfree_skb(nskb);
520         goto out;
521 }
522
523 int llc_conn_ac_send_rej_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
524 {
525         int rc = -ENOBUFS;
526         struct llc_sock *llc = llc_sk(sk);
527         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
528
529         if (nskb) {
530                 struct llc_sap *sap = llc->sap;
531                 u8 f_bit = 0;
532
533                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
534                                     llc->daddr.lsap, LLC_PDU_RSP);
535                 llc_pdu_init_as_rej_rsp(nskb, f_bit, llc->vR);
536                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
537                 if (rc)
538                         goto free;
539                 llc_conn_send_pdu(sk, nskb);
540         }
541 out:
542         return rc;
543 free:
544         kfree_skb(nskb);
545         goto out;
546 }
547
548 int llc_conn_ac_send_rnr_cmd_p_set_1(struct sock *sk, struct sk_buff *skb)
549 {
550         int rc = -ENOBUFS;
551         struct llc_sock *llc = llc_sk(sk);
552         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
553
554         if (nskb) {
555                 struct llc_sap *sap = llc->sap;
556
557                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
558                                     llc->daddr.lsap, LLC_PDU_CMD);
559                 llc_pdu_init_as_rnr_cmd(nskb, 1, llc->vR);
560                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
561                 if (rc)
562                         goto free;
563                 llc_conn_send_pdu(sk, nskb);
564         }
565 out:
566         return rc;
567 free:
568         kfree_skb(nskb);
569         goto out;
570 }
571
572 int llc_conn_ac_send_rnr_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
573 {
574         int rc = -ENOBUFS;
575         struct llc_sock *llc = llc_sk(sk);
576         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
577
578         if (nskb) {
579                 struct llc_sap *sap = llc->sap;
580                 u8 f_bit = 1;
581
582                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
583                                     llc->daddr.lsap, LLC_PDU_RSP);
584                 llc_pdu_init_as_rnr_rsp(nskb, f_bit, llc->vR);
585                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
586                 if (rc)
587                         goto free;
588                 llc_conn_send_pdu(sk, nskb);
589         }
590 out:
591         return rc;
592 free:
593         kfree_skb(nskb);
594         goto out;
595 }
596
597 int llc_conn_ac_send_rnr_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
598 {
599         int rc = -ENOBUFS;
600         struct llc_sock *llc = llc_sk(sk);
601         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
602
603         if (nskb) {
604                 u8 f_bit = 0;
605                 struct llc_sap *sap = llc->sap;
606
607                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
608                                     llc->daddr.lsap, LLC_PDU_RSP);
609                 llc_pdu_init_as_rnr_rsp(nskb, f_bit, llc->vR);
610                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
611                 if (rc)
612                         goto free;
613                 llc_conn_send_pdu(sk, nskb);
614         }
615 out:
616         return rc;
617 free:
618         kfree_skb(nskb);
619         goto out;
620 }
621
622 int llc_conn_ac_set_remote_busy(struct sock *sk, struct sk_buff *skb)
623 {
624         struct llc_sock *llc = llc_sk(sk);
625
626         if (!llc->remote_busy_flag) {
627                 llc->remote_busy_flag = 1;
628                 mod_timer(&llc->busy_state_timer.timer,
629                          jiffies + llc->busy_state_timer.expire * HZ);
630         }
631         return 0;
632 }
633
634 int llc_conn_ac_opt_send_rnr_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
635 {
636         int rc = -ENOBUFS;
637         struct llc_sock *llc = llc_sk(sk);
638         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
639
640         if (nskb) {
641                 struct llc_sap *sap = llc->sap;
642
643                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
644                                     llc->daddr.lsap, LLC_PDU_RSP);
645                 llc_pdu_init_as_rnr_rsp(nskb, 0, llc->vR);
646                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
647                 if (rc)
648                         goto free;
649                 llc_conn_send_pdu(sk, nskb);
650         }
651 out:
652         return rc;
653 free:
654         kfree_skb(nskb);
655         goto out;
656 }
657
658 int llc_conn_ac_send_rr_cmd_p_set_1(struct sock *sk, struct sk_buff *skb)
659 {
660         int rc = -ENOBUFS;
661         struct llc_sock *llc = llc_sk(sk);
662         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
663
664         if (nskb) {
665                 struct llc_sap *sap = llc->sap;
666
667                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
668                                     llc->daddr.lsap, LLC_PDU_CMD);
669                 llc_pdu_init_as_rr_cmd(nskb, 1, llc->vR);
670                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
671                 if (rc)
672                         goto free;
673                 llc_conn_send_pdu(sk, nskb);
674         }
675 out:
676         return rc;
677 free:
678         kfree_skb(nskb);
679         goto out;
680 }
681
682 int llc_conn_ac_send_rr_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
683 {
684         int rc = -ENOBUFS;
685         struct llc_sock *llc = llc_sk(sk);
686         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
687
688         if (nskb) {
689                 struct llc_sap *sap = llc->sap;
690                 u8 f_bit = 1;
691
692                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
693                                     llc->daddr.lsap, LLC_PDU_RSP);
694                 llc_pdu_init_as_rr_rsp(nskb, f_bit, llc->vR);
695                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
696                 if (rc)
697                         goto free;
698                 llc_conn_send_pdu(sk, nskb);
699         }
700 out:
701         return rc;
702 free:
703         kfree_skb(nskb);
704         goto out;
705 }
706
707 int llc_conn_ac_send_ack_rsp_f_set_1(struct sock *sk, struct sk_buff *skb)
708 {
709         int rc = -ENOBUFS;
710         struct llc_sock *llc = llc_sk(sk);
711         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
712
713         if (nskb) {
714                 struct llc_sap *sap = llc->sap;
715                 u8 f_bit = 1;
716
717                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
718                                     llc->daddr.lsap, LLC_PDU_RSP);
719                 llc_pdu_init_as_rr_rsp(nskb, f_bit, llc->vR);
720                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
721                 if (rc)
722                         goto free;
723                 llc_conn_send_pdu(sk, nskb);
724         }
725 out:
726         return rc;
727 free:
728         kfree_skb(nskb);
729         goto out;
730 }
731
732 int llc_conn_ac_send_rr_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
733 {
734         int rc = -ENOBUFS;
735         struct llc_sock *llc = llc_sk(sk);
736         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
737
738         if (nskb) {
739                 struct llc_sap *sap = llc->sap;
740
741                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
742                                     llc->daddr.lsap, LLC_PDU_RSP);
743                 llc_pdu_init_as_rr_rsp(nskb, 0, llc->vR);
744                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
745                 if (rc)
746                         goto free;
747                 llc_conn_send_pdu(sk, nskb);
748         }
749 out:
750         return rc;
751 free:
752         kfree_skb(nskb);
753         goto out;
754 }
755
756 int llc_conn_ac_send_ack_xxx_x_set_0(struct sock *sk, struct sk_buff *skb)
757 {
758         int rc = -ENOBUFS;
759         struct llc_sock *llc = llc_sk(sk);
760         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
761
762         if (nskb) {
763                 struct llc_sap *sap = llc->sap;
764
765                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
766                                     llc->daddr.lsap, LLC_PDU_RSP);
767                 llc_pdu_init_as_rr_rsp(nskb, 0, llc->vR);
768                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
769                 if (rc)
770                         goto free;
771                 llc_conn_send_pdu(sk, nskb);
772         }
773 out:
774         return rc;
775 free:
776         kfree_skb(nskb);
777         goto out;
778 }
779
780 void llc_conn_set_p_flag(struct sock *sk, u8 value)
781 {
782         int state_changed = llc_sk(sk)->p_flag && !value;
783
784         llc_sk(sk)->p_flag = value;
785
786         if (state_changed)
787                 sk->sk_state_change(sk);
788 }
789
790 int llc_conn_ac_send_sabme_cmd_p_set_x(struct sock *sk, struct sk_buff *skb)
791 {
792         int rc = -ENOBUFS;
793         struct llc_sock *llc = llc_sk(sk);
794         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
795
796         if (nskb) {
797                 struct llc_sap *sap = llc->sap;
798                 u8 *dmac = llc->daddr.mac;
799
800                 if (llc->dev->flags & IFF_LOOPBACK)
801                         dmac = llc->dev->dev_addr;
802                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
803                                     llc->daddr.lsap, LLC_PDU_CMD);
804                 llc_pdu_init_as_sabme_cmd(nskb, 1);
805                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, dmac);
806                 if (rc)
807                         goto free;
808                 llc_conn_send_pdu(sk, nskb);
809                 llc_conn_set_p_flag(sk, 1);
810         }
811 out:
812         return rc;
813 free:
814         kfree_skb(nskb);
815         goto out;
816 }
817
818 int llc_conn_ac_send_ua_rsp_f_set_p(struct sock *sk, struct sk_buff *skb)
819 {
820         u8 f_bit;
821         int rc = -ENOBUFS;
822         struct llc_sock *llc = llc_sk(sk);
823         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
824
825         llc_pdu_decode_pf_bit(skb, &f_bit);
826         if (nskb) {
827                 struct llc_sap *sap = llc->sap;
828
829                 nskb->dev = llc->dev;
830                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_U, sap->laddr.lsap,
831                                     llc->daddr.lsap, LLC_PDU_RSP);
832                 llc_pdu_init_as_ua_rsp(nskb, f_bit);
833                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
834                 if (rc)
835                         goto free;
836                 llc_conn_send_pdu(sk, nskb);
837         }
838 out:
839         return rc;
840 free:
841         kfree_skb(nskb);
842         goto out;
843 }
844
845 int llc_conn_ac_set_s_flag_0(struct sock *sk, struct sk_buff *skb)
846 {
847         llc_sk(sk)->s_flag = 0;
848         return 0;
849 }
850
851 int llc_conn_ac_set_s_flag_1(struct sock *sk, struct sk_buff *skb)
852 {
853         llc_sk(sk)->s_flag = 1;
854         return 0;
855 }
856
857 int llc_conn_ac_start_p_timer(struct sock *sk, struct sk_buff *skb)
858 {
859         struct llc_sock *llc = llc_sk(sk);
860
861         llc_conn_set_p_flag(sk, 1);
862         mod_timer(&llc->pf_cycle_timer.timer,
863                   jiffies + llc->pf_cycle_timer.expire * HZ);
864         return 0;
865 }
866
867 /**
868  *      llc_conn_ac_send_ack_if_needed - check if ack is needed
869  *      @sk: current connection structure
870  *      @skb: current event
871  *
872  *      Checks number of received PDUs which have not been acknowledged, yet,
873  *      If number of them reaches to "npta"(Number of PDUs To Acknowledge) then
874  *      sends an RR response as acknowledgement for them.  Returns 0 for
875  *      success, 1 otherwise.
876  */
877 int llc_conn_ac_send_ack_if_needed(struct sock *sk, struct sk_buff *skb)
878 {
879         u8 pf_bit;
880         struct llc_sock *llc = llc_sk(sk);
881
882         llc_pdu_decode_pf_bit(skb, &pf_bit);
883         llc->ack_pf |= pf_bit & 1;
884         if (!llc->ack_must_be_send) {
885                 llc->first_pdu_Ns = llc->vR;
886                 llc->ack_must_be_send = 1;
887                 llc->ack_pf = pf_bit & 1;
888         }
889         if (((llc->vR - llc->first_pdu_Ns + 129) % 128) >= llc->npta) {
890                 llc_conn_ac_send_rr_rsp_f_set_ackpf(sk, skb);
891                 llc->ack_must_be_send   = 0;
892                 llc->ack_pf             = 0;
893                 llc_conn_ac_inc_npta_value(sk, skb);
894         }
895         return 0;
896 }
897
898 /**
899  *      llc_conn_ac_rst_sendack_flag - resets ack_must_be_send flag
900  *      @sk: current connection structure
901  *      @skb: current event
902  *
903  *      This action resets ack_must_be_send flag of given connection, this flag
904  *      indicates if there is any PDU which has not been acknowledged yet.
905  *      Returns 0 for success, 1 otherwise.
906  */
907 int llc_conn_ac_rst_sendack_flag(struct sock *sk, struct sk_buff *skb)
908 {
909         llc_sk(sk)->ack_must_be_send = llc_sk(sk)->ack_pf = 0;
910         return 0;
911 }
912
913 /**
914  *      llc_conn_ac_send_i_rsp_f_set_ackpf - acknowledge received PDUs
915  *      @sk: current connection structure
916  *      @skb: current event
917  *
918  *      Sends an I response PDU with f-bit set to ack_pf flag as acknowledge to
919  *      all received PDUs which have not been acknowledged, yet. ack_pf flag is
920  *      set to one if one PDU with p-bit set to one is received.  Returns 0 for
921  *      success, 1 otherwise.
922  */
923 static int llc_conn_ac_send_i_rsp_f_set_ackpf(struct sock *sk,
924                                               struct sk_buff *skb)
925 {
926         int rc;
927         struct llc_sock *llc = llc_sk(sk);
928         struct llc_sap *sap = llc->sap;
929
930         llc_pdu_header_init(skb, LLC_PDU_TYPE_I, sap->laddr.lsap,
931                             llc->daddr.lsap, LLC_PDU_RSP);
932         llc_pdu_init_as_i_cmd(skb, llc->ack_pf, llc->vS, llc->vR);
933         rc = llc_mac_hdr_init(skb, llc->dev->dev_addr, llc->daddr.mac);
934         if (!rc) {
935                 llc_conn_send_pdu(sk, skb);
936                 llc_conn_ac_inc_vs_by_1(sk, skb);
937         }
938         return rc;
939 }
940
941 /**
942  *      llc_conn_ac_send_i_as_ack - sends an I-format PDU to acknowledge rx PDUs
943  *      @sk: current connection structure.
944  *      @skb: current event.
945  *
946  *      This action sends an I-format PDU as acknowledge to received PDUs which
947  *      have not been acknowledged, yet, if there is any. By using of this
948  *      action number of acknowledgements decreases, this technic is called
949  *      piggy backing. Returns 0 for success, 1 otherwise.
950  */
951 int llc_conn_ac_send_i_as_ack(struct sock *sk, struct sk_buff *skb)
952 {
953         struct llc_sock *llc = llc_sk(sk);
954
955         if (llc->ack_must_be_send) {
956                 llc_conn_ac_send_i_rsp_f_set_ackpf(sk, skb);
957                 llc->ack_must_be_send = 0 ;
958                 llc->ack_pf = 0;
959         } else
960                 llc_conn_ac_send_i_cmd_p_set_0(sk, skb);
961         return 0;
962 }
963
964 /**
965  *      llc_conn_ac_send_rr_rsp_f_set_ackpf - ack all rx PDUs not yet acked
966  *      @sk: current connection structure.
967  *      @skb: current event.
968  *
969  *      This action sends an RR response with f-bit set to ack_pf flag as
970  *      acknowledge to all received PDUs which have not been acknowledged, yet,
971  *      if there is any. ack_pf flag indicates if a PDU has been received with
972  *      p-bit set to one. Returns 0 for success, 1 otherwise.
973  */
974 static int llc_conn_ac_send_rr_rsp_f_set_ackpf(struct sock *sk,
975                                                struct sk_buff *skb)
976 {
977         int rc = -ENOBUFS;
978         struct llc_sock *llc = llc_sk(sk);
979         struct sk_buff *nskb = llc_alloc_frame(llc->dev);
980
981         if (nskb) {
982                 struct llc_sap *sap = llc->sap;
983
984                 llc_pdu_header_init(nskb, LLC_PDU_TYPE_S, sap->laddr.lsap,
985                                     llc->daddr.lsap, LLC_PDU_RSP);
986                 llc_pdu_init_as_rr_rsp(nskb, llc->ack_pf, llc->vR);
987                 rc = llc_mac_hdr_init(nskb, llc->dev->dev_addr, llc->daddr.mac);
988                 if (rc)
989                         goto free;
990                 llc_conn_send_pdu(sk, nskb);
991         }
992 out:
993         return rc;
994 free:
995         kfree_skb(nskb);
996         goto out;
997 }
998
999 /**
1000  *      llc_conn_ac_inc_npta_value - tries to make value of npta greater
1001  *      @sk: current connection structure.
1002  *      @skb: current event.
1003  *
1004  *      After "inc_cntr" times calling of this action, "npta" increase by one.
1005  *      this action tries to make vale of "npta" greater as possible; number of
1006  *      acknowledgements decreases by increasing of "npta". Returns 0 for
1007  *      success, 1 otherwise.
1008  */
1009 static int llc_conn_ac_inc_npta_value(struct sock *sk, struct sk_buff *skb)
1010 {
1011         struct llc_sock *llc = llc_sk(sk);
1012
1013         if (!llc->inc_cntr) {
1014                 llc->dec_step = 0;
1015                 llc->dec_cntr = llc->inc_cntr = 2;
1016                 ++llc->npta;
1017                 if (llc->npta > 127)
1018                         llc->npta = 127 ;
1019         } else
1020                 --llc->inc_cntr;
1021         return 0;
1022 }
1023
1024 /**
1025  *      llc_conn_ac_adjust_npta_by_rr - decreases "npta" by one
1026  *      @sk: current connection structure.
1027  *      @skb: current event.
1028  *
1029  *      After receiving "dec_cntr" times RR command, this action decreases
1030  *      "npta" by one. Returns 0 for success, 1 otherwise.
1031  */
1032 int llc_conn_ac_adjust_npta_by_rr(struct sock *sk, struct sk_buff *skb)
1033 {
1034         struct llc_sock *llc = llc_sk(sk);
1035
1036         if (!llc->connect_step && !llc->remote_busy_flag) {
1037                 if (!llc->dec_step) {
1038                         if (!llc->dec_cntr) {
1039                                 llc->inc_cntr = llc->dec_cntr = 2;
1040                                 if (llc->npta > 0)
1041                                         llc->npta = llc->npta - 1;
1042                         } else
1043                                 llc->dec_cntr -=1;
1044                 }
1045         } else
1046                 llc->connect_step = 0 ;
1047         return 0;
1048 }
1049
1050 /**
1051  *      llc_conn_ac_adjust_npta_by_rnr - decreases "npta" by one
1052  *      @sk: current connection structure.
1053  *      @skb: current event.
1054  *
1055  *      After receiving "dec_cntr" times RNR command, this action decreases
1056  *      "npta" by one. Returns 0 for success, 1 otherwise.
1057  */
1058 int llc_conn_ac_adjust_npta_by_rnr(struct sock *sk, struct sk_buff *skb)
1059 {
1060         struct llc_sock *llc = llc_sk(sk);
1061
1062         if (llc->remote_busy_flag)
1063                 if (!llc->dec_step) {
1064                         if (!llc->dec_cntr) {
1065                                 llc->inc_cntr = llc->dec_cntr = 2;
1066                                 if (llc->npta > 0)
1067                                         --llc->npta;
1068                         } else
1069                                 --llc->dec_cntr;
1070                 }
1071         return 0;
1072 }
1073
1074 /**
1075  *      llc_conn_ac_dec_tx_win_size - decreases tx window size
1076  *      @sk: current connection structure.
1077  *      @skb: current event.
1078  *
1079  *      After receiving of a REJ command or response, transmit window size is
1080  *      decreased by number of PDUs which are outstanding yet. Returns 0 for
1081  *      success, 1 otherwise.
1082  */
1083 int llc_conn_ac_dec_tx_win_size(struct sock *sk, struct sk_buff *skb)
1084 {
1085         struct llc_sock *llc = llc_sk(sk);
1086         u8 unacked_pdu = skb_queue_len(&llc->pdu_unack_q);
1087
1088         llc->k -= unacked_pdu;
1089         if (llc->k < 2)
1090                 llc->k = 2;
1091         return 0;
1092 }
1093
1094 /**
1095  *      llc_conn_ac_inc_tx_win_size - tx window size is inc by 1
1096  *      @sk: current connection structure.
1097  *      @skb: current event.
1098  *
1099  *      After receiving an RR response with f-bit set to one, transmit window
1100  *      size is increased by one. Returns 0 for success, 1 otherwise.
1101  */
1102 int llc_conn_ac_inc_tx_win_size(struct sock *sk, struct sk_buff *skb)
1103 {
1104         struct llc_sock *llc = llc_sk(sk);
1105
1106         llc->k += 1;
1107         if (llc->k > 128)
1108                 llc->k = 128 ;
1109         return 0;
1110 }
1111
1112 int llc_conn_ac_stop_all_timers(struct sock *sk, struct sk_buff *skb)
1113 {
1114         struct llc_sock *llc = llc_sk(sk);
1115
1116         del_timer(&llc->pf_cycle_timer.timer);
1117         del_timer(&llc->ack_timer.timer);
1118         del_timer(&llc->rej_sent_timer.timer);
1119         del_timer(&llc->busy_state_timer.timer);
1120         llc->ack_must_be_send = 0;
1121         llc->ack_pf = 0;
1122         return 0;
1123 }
1124
1125 int llc_conn_ac_stop_other_timers(struct sock *sk, struct sk_buff *skb)
1126 {
1127         struct llc_sock *llc = llc_sk(sk);
1128
1129         del_timer(&llc->rej_sent_timer.timer);
1130         del_timer(&llc->pf_cycle_timer.timer);
1131         del_timer(&llc->busy_state_timer.timer);
1132         llc->ack_must_be_send = 0;
1133         llc->ack_pf = 0;
1134         return 0;
1135 }
1136
1137 int llc_conn_ac_start_ack_timer(struct sock *sk, struct sk_buff *skb)
1138 {
1139         struct llc_sock *llc = llc_sk(sk);
1140
1141         mod_timer(&llc->ack_timer.timer, jiffies + llc->ack_timer.expire * HZ);
1142         return 0;
1143 }
1144
1145 int llc_conn_ac_start_rej_timer(struct sock *sk, struct sk_buff *skb)
1146 {
1147         struct llc_sock *llc = llc_sk(sk);
1148
1149         mod_timer(&llc->rej_sent_timer.timer,
1150                   jiffies + llc->rej_sent_timer.expire * HZ);
1151         return 0;
1152 }
1153
1154 int llc_conn_ac_start_ack_tmr_if_not_running(struct sock *sk,
1155                                              struct sk_buff *skb)
1156 {
1157         struct llc_sock *llc = llc_sk(sk);
1158
1159         if (!timer_pending(&llc->ack_timer.timer))
1160                 mod_timer(&llc->ack_timer.timer,
1161                           jiffies + llc->ack_timer.expire * HZ);
1162         return 0;
1163 }
1164
1165 int llc_conn_ac_stop_ack_timer(struct sock *sk, struct sk_buff *skb)
1166 {
1167         del_timer(&llc_sk(sk)->ack_timer.timer);
1168         return 0;
1169 }
1170
1171 int llc_conn_ac_stop_p_timer(struct sock *sk, struct sk_buff *skb)
1172 {
1173         struct llc_sock *llc = llc_sk(sk);
1174
1175         del_timer(&llc->pf_cycle_timer.timer);
1176         llc_conn_set_p_flag(sk, 0);
1177         return 0;
1178 }
1179
1180 int llc_conn_ac_stop_rej_timer(struct sock *sk, struct sk_buff *skb)
1181 {
1182         del_timer(&llc_sk(sk)->rej_sent_timer.timer);
1183         return 0;
1184 }
1185
1186 int llc_conn_ac_upd_nr_received(struct sock *sk, struct sk_buff *skb)
1187 {
1188         int acked;
1189         u16 unacked = 0;
1190         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
1191         struct llc_sock *llc = llc_sk(sk);
1192
1193         llc->last_nr = PDU_SUPV_GET_Nr(pdu);
1194         acked = llc_conn_remove_acked_pdus(sk, llc->last_nr, &unacked);
1195         /* On loopback we don't queue I frames in unack_pdu_q queue. */
1196         if (acked > 0 || (llc->dev->flags & IFF_LOOPBACK)) {
1197                 llc->retry_count = 0;
1198                 del_timer(&llc->ack_timer.timer);
1199                 if (llc->failed_data_req) {
1200                         /* already, we did not accept data from upper layer
1201                          * (tx_window full or unacceptable state). Now, we
1202                          * can send data and must inform to upper layer.
1203                          */
1204                         llc->failed_data_req = 0;
1205                         llc_conn_ac_data_confirm(sk, skb);
1206                 }
1207                 if (unacked)
1208                         mod_timer(&llc->ack_timer.timer,
1209                                   jiffies + llc->ack_timer.expire * HZ);
1210         } else if (llc->failed_data_req) {
1211                 u8 f_bit;
1212
1213                 llc_pdu_decode_pf_bit(skb, &f_bit);
1214                 if (f_bit == 1) {
1215                         llc->failed_data_req = 0;
1216                         llc_conn_ac_data_confirm(sk, skb);
1217                 }
1218         }
1219         return 0;
1220 }
1221
1222 int llc_conn_ac_upd_p_flag(struct sock *sk, struct sk_buff *skb)
1223 {
1224         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
1225
1226         if (LLC_PDU_IS_RSP(pdu)) {
1227                 u8 f_bit;
1228
1229                 llc_pdu_decode_pf_bit(skb, &f_bit);
1230                 if (f_bit) {
1231                         llc_conn_set_p_flag(sk, 0);
1232                         llc_conn_ac_stop_p_timer(sk, skb);
1233                 }
1234         }
1235         return 0;
1236 }
1237
1238 int llc_conn_ac_set_data_flag_2(struct sock *sk, struct sk_buff *skb)
1239 {
1240         llc_sk(sk)->data_flag = 2;
1241         return 0;
1242 }
1243
1244 int llc_conn_ac_set_data_flag_0(struct sock *sk, struct sk_buff *skb)
1245 {
1246         llc_sk(sk)->data_flag = 0;
1247         return 0;
1248 }
1249
1250 int llc_conn_ac_set_data_flag_1(struct sock *sk, struct sk_buff *skb)
1251 {
1252         llc_sk(sk)->data_flag = 1;
1253         return 0;
1254 }
1255
1256 int llc_conn_ac_set_data_flag_1_if_data_flag_eq_0(struct sock *sk,
1257                                                   struct sk_buff *skb)
1258 {
1259         if (!llc_sk(sk)->data_flag)
1260                 llc_sk(sk)->data_flag = 1;
1261         return 0;
1262 }
1263
1264 int llc_conn_ac_set_p_flag_0(struct sock *sk, struct sk_buff *skb)
1265 {
1266         llc_conn_set_p_flag(sk, 0);
1267         return 0;
1268 }
1269
1270 static int llc_conn_ac_set_p_flag_1(struct sock *sk, struct sk_buff *skb)
1271 {
1272         llc_conn_set_p_flag(sk, 1);
1273         return 0;
1274 }
1275
1276 int llc_conn_ac_set_remote_busy_0(struct sock *sk, struct sk_buff *skb)
1277 {
1278         llc_sk(sk)->remote_busy_flag = 0;
1279         return 0;
1280 }
1281
1282 int llc_conn_ac_set_cause_flag_0(struct sock *sk, struct sk_buff *skb)
1283 {
1284         llc_sk(sk)->cause_flag = 0;
1285         return 0;
1286 }
1287
1288 int llc_conn_ac_set_cause_flag_1(struct sock *sk, struct sk_buff *skb)
1289 {
1290         llc_sk(sk)->cause_flag = 1;
1291         return 0;
1292 }
1293
1294 int llc_conn_ac_set_retry_cnt_0(struct sock *sk, struct sk_buff *skb)
1295 {
1296         llc_sk(sk)->retry_count = 0;
1297         return 0;
1298 }
1299
1300 int llc_conn_ac_inc_retry_cnt_by_1(struct sock *sk, struct sk_buff *skb)
1301 {
1302         llc_sk(sk)->retry_count++;
1303         return 0;
1304 }
1305
1306 int llc_conn_ac_set_vr_0(struct sock *sk, struct sk_buff *skb)
1307 {
1308         llc_sk(sk)->vR = 0;
1309         return 0;
1310 }
1311
1312 int llc_conn_ac_inc_vr_by_1(struct sock *sk, struct sk_buff *skb)
1313 {
1314         llc_sk(sk)->vR = PDU_GET_NEXT_Vr(llc_sk(sk)->vR);
1315         return 0;
1316 }
1317
1318 int llc_conn_ac_set_vs_0(struct sock *sk, struct sk_buff *skb)
1319 {
1320         llc_sk(sk)->vS = 0;
1321         return 0;
1322 }
1323
1324 int llc_conn_ac_set_vs_nr(struct sock *sk, struct sk_buff *skb)
1325 {
1326         llc_sk(sk)->vS = llc_sk(sk)->last_nr;
1327         return 0;
1328 }
1329
1330 int llc_conn_ac_inc_vs_by_1(struct sock *sk, struct sk_buff *skb)
1331 {
1332         llc_sk(sk)->vS = (llc_sk(sk)->vS + 1) % 128;
1333         return 0;
1334 }
1335
1336 void llc_conn_pf_cycle_tmr_cb(unsigned long timeout_data)
1337 {
1338         struct sock *sk = (struct sock *)timeout_data;
1339         struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
1340
1341         bh_lock_sock(sk);
1342         if (skb) {
1343                 struct llc_conn_state_ev *ev = llc_conn_ev(skb);
1344
1345                 skb->sk  = sk;
1346                 ev->type = LLC_CONN_EV_TYPE_P_TMR;
1347                 llc_process_tmr_ev(sk, skb);
1348         }
1349         bh_unlock_sock(sk);
1350 }
1351
1352 void llc_conn_busy_tmr_cb(unsigned long timeout_data)
1353 {
1354         struct sock *sk = (struct sock *)timeout_data;
1355         struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
1356
1357         bh_lock_sock(sk);
1358         if (skb) {
1359                 struct llc_conn_state_ev *ev = llc_conn_ev(skb);
1360
1361                 skb->sk  = sk;
1362                 ev->type = LLC_CONN_EV_TYPE_BUSY_TMR;
1363                 llc_process_tmr_ev(sk, skb);
1364         }
1365         bh_unlock_sock(sk);
1366 }
1367
1368 void llc_conn_ack_tmr_cb(unsigned long timeout_data)
1369 {
1370         struct sock* sk = (struct sock *)timeout_data;
1371         struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
1372
1373         bh_lock_sock(sk);
1374         if (skb) {
1375                 struct llc_conn_state_ev *ev = llc_conn_ev(skb);
1376
1377                 skb->sk  = sk;
1378                 ev->type = LLC_CONN_EV_TYPE_ACK_TMR;
1379                 llc_process_tmr_ev(sk, skb);
1380         }
1381         bh_unlock_sock(sk);
1382 }
1383
1384 void llc_conn_rej_tmr_cb(unsigned long timeout_data)
1385 {
1386         struct sock *sk = (struct sock *)timeout_data;
1387         struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
1388
1389         bh_lock_sock(sk);
1390         if (skb) {
1391                 struct llc_conn_state_ev *ev = llc_conn_ev(skb);
1392
1393                 skb->sk  = sk;
1394                 ev->type = LLC_CONN_EV_TYPE_REJ_TMR;
1395                 llc_process_tmr_ev(sk, skb);
1396         }
1397         bh_unlock_sock(sk);
1398 }
1399
1400 int llc_conn_ac_rst_vs(struct sock *sk, struct sk_buff *skb)
1401 {
1402         llc_sk(sk)->X = llc_sk(sk)->vS;
1403         llc_conn_ac_set_vs_nr(sk, skb);
1404         return 0;
1405 }
1406
1407 int llc_conn_ac_upd_vs(struct sock *sk, struct sk_buff *skb)
1408 {
1409         struct llc_pdu_sn *pdu = llc_pdu_sn_hdr(skb);
1410         u8 nr = PDU_SUPV_GET_Nr(pdu);
1411
1412         if (llc_circular_between(llc_sk(sk)->vS, nr, llc_sk(sk)->X))
1413                 llc_conn_ac_set_vs_nr(sk, skb);
1414         return 0;
1415 }
1416
1417 /*
1418  * Non-standard actions; these not contained in IEEE specification; for
1419  * our own usage
1420  */
1421 /**
1422  *      llc_conn_disc - removes connection from SAP list and frees it
1423  *      @sk: closed connection
1424  *      @skb: occurred event
1425  */
1426 int llc_conn_disc(struct sock *sk, struct sk_buff *skb)
1427 {
1428         /* FIXME: this thing seems to want to die */
1429         return 0;
1430 }
1431
1432 /**
1433  *      llc_conn_reset - resets connection
1434  *      @sk : reseting connection.
1435  *      @skb: occurred event.
1436  *
1437  *      Stop all timers, empty all queues and reset all flags.
1438  */
1439 int llc_conn_reset(struct sock *sk, struct sk_buff *skb)
1440 {
1441         llc_sk_reset(sk);
1442         return 0;
1443 }
1444
1445 /**
1446  *      llc_circular_between - designates that b is between a and c or not
1447  *      @a: lower bound
1448  *      @b: element to see if is between a and b
1449  *      @c: upper bound
1450  *
1451  *      This function designates that b is between a and c or not (for example,
1452  *      0 is between 127 and 1). Returns 1 if b is between a and c, 0
1453  *      otherwise.
1454  */
1455 u8 llc_circular_between(u8 a, u8 b, u8 c)
1456 {
1457         b = b - a;
1458         c = c - a;
1459         return b <= c;
1460 }
1461
1462 /**
1463  *      llc_process_tmr_ev - timer backend
1464  *      @sk: active connection
1465  *      @skb: occurred event
1466  *
1467  *      This function is called from timer callback functions. When connection
1468  *      is busy (during sending a data frame) timer expiration event must be
1469  *      queued. Otherwise this event can be sent to connection state machine.
1470  *      Queued events will process by llc_backlog_rcv function after sending
1471  *      data frame.
1472  */
1473 static void llc_process_tmr_ev(struct sock *sk, struct sk_buff *skb)
1474 {
1475         if (llc_sk(sk)->state == LLC_CONN_OUT_OF_SVC) {
1476                 printk(KERN_WARNING "%s: timer called on closed connection\n",
1477                        __FUNCTION__);
1478                 kfree_skb(skb);
1479         } else {
1480                 if (!sock_owned_by_user(sk))
1481                         llc_conn_state_process(sk, skb);
1482                 else {
1483                         llc_set_backlog_type(skb, LLC_EVENT);
1484                         sk_add_backlog(sk, skb);
1485                 }
1486         }
1487 }