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