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